Este é daqueles comandos que as vezes nos esquecemos e nos fazem falta. Para alterar a senha sudo em ambiente Linux abra a janela do Terminal e execute o seguinte comando:
~$ sudo passwd seu_nome_de_usuario_aqui
Ser á solicitada a nova senha:
Enter new UNIX password:
Digite e será solicitado que repita a senha:
Retype new UNIX password:
Ao redigitar é exibida a mensagem abaixo e a senha sudo está atualizada!
Agendando Tarefas Utilizando Quartz e Spring Framework
Ano passado, fui convidado pela equipe da Easy Java Magazine a escrever este artigo, que trata sobre como integrar as bibliotecas do agendador de tarefas Quartz em aplicações que utilizem o Spring Framework.
Abaixo o link direto para a página da matéria que saiu na revista Easy Java Magazine #25:
As linguagens de programações atuais, esbanjam praticidade quando o assunto é ordenação de listas.
Com pouquíssimas linhas como mostrado aqui em posts anteriores, podemos ordenar nossas listas.
Para quem gosta de brincar com algoritmos, vamos desenvolver neste pequeno tutorial o Algoritmo Bubble Sort, bastante conhecido.
É interessante se conhecer a forma de aplicar tais algoritmos, pois não é em todas linguagens que temos tanta praticidade para ordenar listas.
Conhecer um algoritmo de ordenação, como o Bubble Sort, por exemplo, é uma boa ideia quando se trabalha programando para dispositivos com capacidades computacionais reduzidas como microcontroladores.
Conhecendo o Algoritmo Bubble Sort
No vídeo abaixo, um grupo de dança demonstra de forma muito bem humorada o funcionamento do Algoritmo Bubble Sort:
O algoritmo consiste basicamente em ordenar um vetor de nposições, a partir de pequenas partes do mesmo.
O algoritmo varre o vetor, ordenando os pares. Como demonstra a figura abaixo:
Após concluir a ordenação por pares, pode ocorrer do vetor ainda não estar ordenado conforme se deseja. Assim sendo o algoritmo deve ser executado de forma recursiva até que a ordenação do vetor se complete.
Abaixo, descrevemos um código que carrega um vetor carregado com números aleatoriamente.
/**
* Preenche o vetor com numeros aleatórios
*/
for (int i = 0; i < vetor.length; i++) {
vetor[i] = (int) (Math.random() * 100);
}
Após executa um método que exibe o vetor (ainda fora de ordem) na tela.
/**
* Metodo que recebe um vetor e exibe o mesmo na tela
*/
private void exibeVetor(int[] v) {
System.out.println("\n");
for (int i = 0; i < v.length; i++) {
System.out.print(v[i] + " ");
}
}
Agora é hora da mágica! O método abaixo ordena o vetor, verificando os valores contidos nos índices e comparando-os com os valores do próximo índice. Caso o valor do índice atual for menor do que do índice posterior, ele inverte a posição dos mesmos, com o auxilio de uma variável de controle.
/**
* Metodo responsavel por varrer o vetor e ordenar os pares
*/
private void ordenaBubbleSort(int[] v) {
for (int i = 0; i < v.length; i++) {
/**
* Caso o índice atual do vetor for o ultimo, não precisa ordenar
*/
if (i != v.length - 1) {
/**
* Verifica se os valores não estão em ordem crescente
*/
if (!(v[i] <= v[i + 1])) {
/**
* atribui o valor do indice a uma variavel temporaria
*/
int valorTemp = v[i];
/**
* coloca o valor do proximo indice no indice atual
*/
v[i] = v[i + 1];
/**
* atribui o valor da variavel temporaria no proximo indice
*/
v[i + 1] = valorTemp;
}
}
}
if (!isVetorOrdenado(v)) {
ordenaBubbleSort(v);
}
}
O método abaixo verifica se o vetor esta em ordem.
/**
* Metodo que verifica se o vetor está em ordem
* Retorna 'true' se estiver atualizado
*/
private boolean isVetorOrdenado(int[] v) {
for (int i = 0; i < v.length; i++) {
/**
* Caso o índice atual do vetor for o ultimo, não precisa ordenar
*/
if (i != v.length - 1) {
/**
* Verifica se o indice atual e o próximo estão ordenados;
*
* Caso estejam, checa os proximos indices
*/
if (!(v[i] <= v[i + 1])) {
return false;
}
}
}
return true;
}
Finalmente, acrescentamos o trecho abaixo, no final do método ordenaBubbleSort(), de forma a definir se é ou não necessária a recursão.
if (!isVetorOrdenado(v)) {
ordenaBubbleSort(v);
}
Após, evocamos finalmente o método exibeVetor() para mostrá-lo na tela.
Abaixo a classe completa, já com o método main();
package bubblesort;
public class BubbleSort {
/**
* Constante com o tamanho do vetor a ser criado
*/
public static final int TAMANHO_VETOR = 11;
public static void main(String[] args) {
BubbleSort bubbleSort = new BubbleSort();
int[] vetor = new int[TAMANHO_VETOR];
/**
* Preenche o vetor com numeros aleatórios
*/
for (int i = 0; i < vetor.length; i++) {
vetor[i] = (int) (Math.random() * 100);
}
bubbleSort.exibeVetor(vetor);
bubbleSort.ordenaBubbleSort(vetor);
bubbleSort.exibeVetor(vetor);
}
/**
* Metodo responsavel por varrer o vetor e ordenar os pares
*/
private void ordenaBubbleSort(int[] v) {
for (int i = 0; i < v.length; i++) {
/**
* Caso o índice atual do vetor for o ultimo, não precisa ordenar
*/
if (i != v.length - 1) {
/**
* Verifica se os valores não estão em ordem crescente
*/
if (!(v[i] <= v[i + 1])) {
/**
* atribui o valor do indice a uma variavel temporaria
*/
int valorTemp = v[i];
/**
* coloca o valor do proximo indice no indice atual
*/
v[i] = v[i + 1];
/**
* atribui o valor da variavel temporaria no proximo indice
*/
v[i + 1] = valorTemp;
}
}
}
if (!isVetorOrdenado(v)) {
ordenaBubbleSort(v);
}
}
/**
* Metodo que verifica se o vetor está em ordem
* Retorna 'true' se estiver atualizado
*/
private boolean isVetorOrdenado(int[] v) {
for (int i = 0; i < v.length; i++) {
/**
* Caso o índice atual do vetor for o ultimo, não precisa ordenar
*/
if (i != v.length - 1) {
/**
* Verifica se o indice atual e o próximo estão ordenados;
*
* Caso estejam, checa os proximos indices
*/
if (!(v[i] <= v[i + 1])) {
return false;
}
}
}
return true;
}
/**
* Metodo que recebe um vetor e exibe o mesmo na tela
*/
private void exibeVetor(int[] v) {
System.out.println("\n");
for (int i = 0; i < v.length; i++) {
System.out.print(v[i] + " ");
}
}
}
Nos post anterior falamos de como ordenar objetos em uma lista a partir de um atributo do mesmo. Mas e se quisermos permitir diversas formas de se ordenar um objeto? Para tal, utilizamos a interface Comparator. Aproveitaremos a mesma classe Pessoa já criada no post anteriore implementaremos classes internas à mesma. Vamos criar modos para ordenar por Sobrenome e por Nome. Abaixo a classe interna (inner class) para ordenação por Nome, que deverá ser inserida dentro da classe Pessoa:
/**
* Classe interna que ordena Pessoa pelo atributo Nome
*/
public static class OrdenarPorNome implements Comparator<Pessoa>{
@Override
public int compare(Pessoa o1, Pessoa o2) {
return o1.getNome().compareTo(o2.getNome());
}
}
Vamos aproveitar e criar outra classe interna (inner class) para ordenação por Sobrenome, que também deverá ser inserida dentro da classe Pessoa:
/**
* Classe interna que ordena Pessoa pelo atributo Sobrenome
*/
public static class OrdenarPorSobrenome implements Comparator<Pessoa>{
@Override
public int compare(Pessoa o1, Pessoa o2) {
return o1.getSobreNome().compareTo(o2.getSobreNome());
}
}
Assim, a classe Pessoa deve ficar da seguinte forma, já com a adição das classes internas:
package br.com.devfacil.model;
import java.util.Comparator;
public class Pessoa implements Comparable<Pessoa> {
private String nome;
private String sobreNome;
private Integer idade;
public Pessoa(String nome, String sobreNome, Integer idade) {
this.nome = nome;
this.sobreNome = sobreNome;
this.idade = idade;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getSobreNome() {
return sobreNome;
}
public void setSobreNome(String sobreNome) {
this.sobreNome = sobreNome;
}
public Integer getIdade() {
return idade;
}
public void setIdade(Integer idade) {
this.idade = idade;
}
@Override
public int compareTo(Pessoa pessoaComparacao) {
int idadeComparacao = ((Pessoa) pessoaComparacao).getIdade();
/**
* Ordena as idades de forma Descrescente
*/
return idadeComparacao - this.idade;
}
/**
* Classe interna que ordena Pessoa pelo atributo Nome
*/
public static class OrdenarPorNome implements Comparator<Pessoa>{
@Override
public int compare(Pessoa o1, Pessoa o2) {
return o1.getNome().compareTo(o2.getNome());
}
}
/**
* Classe interna que ordena Pessoa pelo atributo Sobrenome
*/
public static class OrdenarPorSobrenome implements Comparator<Pessoa>{
@Override
public int compare(Pessoa o1, Pessoa o2) {
return o1.getSobreNome().compareTo(o2.getSobreNome());
}
}
}
Vamos modificar agora a classe principal, e a chamada do método Collections.sort() já descrita no post anterior, desta vez, vamos incluir a chamada para as classes internas, como parâmetro do método, conforme o trecho abaixo:
/**
* Ordena por nome
*/
Collections.sort(listaPessoas, new Pessoa.OrdenarPorNome());
Abaixo, a classe principal do post anterior, já com a adição da chamada para ordenação por nome e sobrenome:
package br.com.devfacil.view;
import br.com.devfacil.model.Pessoa;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SortListMain {
public static void main(String[] args) {
/**
* Cria lista de Pessoas
*/
List<Pessoa> listaPessoas = new ArrayList<Pessoa>();
/**
* Atribui 'Nome', 'Sobrenome' e 'Idade' fazendo uso do contrutor com
* parametros de Pessoa(String nome, String sobreNome, Integer idade);
*/
listaPessoas.add(new Pessoa("Ana", "Dias", 40));
listaPessoas.add(new Pessoa("Pedro", "Serafim", 30));
listaPessoas.add(new Pessoa("Maria", "Cavalcante", 58));
listaPessoas.add(new Pessoa("Beatriz", "Silva", 27));
/**
* Ordena por nome
*/
Collections.sort(listaPessoas, new Pessoa.OrdenarPorNome());
System.out.println("\n Lista Ordenada por Nome:");
for (Pessoa p : listaPessoas) {
System.out.println("Nome: " + p.getNome() + ", Sobrenome: " + p.getSobreNome() + ", Idade: " + p.getIdade());
}
/**
* Ordena por Sobrenome
*/
Collections.sort(listaPessoas, new Pessoa.OrdenarPorSobrenome());
System.out.println("\n Lista Ordenada por Sobrenome:");
for (Pessoa p : listaPessoas) {
System.out.println("Nome: " + p.getNome() + ", Sobrenome: " + p.getSobreNome() + ", Idade: " + p.getIdade());
}
}
}
Nopost anterior, falamos de ordenação de listas, e ordenamos alfabeticamente uma lista de nomes. A ordenação alfabética é simples e intuitiva para qualquer leitor, porém, e quando queremos ordenar objetos, que nós mesmos criamos dentro do código? Quando queremos ordenar esta lista de objetos, segundo regras criadas por nós mesmos? Neste breve tutorial, vamos exemplificar o uso da interface Comparable e do metodo compareTo() Começaremos criando a classe Pessoa possuindo como atributos, Nome, Sobrenome e Idade:
package br.com.devfacil.model;
public class Pessoa {
private String nome;
private String sobreNome;
private Integer idade;
public Pessoa(String nome, String sobreNome, Integer idade) {
this.nome = nome;
this.sobreNome = sobreNome;
this.idade = idade;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getSobreNome() {
return sobreNome;
}
public void setSobreNome(String sobreNome) {
this.sobreNome = sobreNome;
}
public Integer getIdade() {
return idade;
}
public void setIdade(Integer idade) {
this.idade = idade;
}
}
Feito isto criaremos nossa classe principal, com o metodo main(), que criará uma lista de Pessoa, a preencherá e a ordenará, como no exemplo do post anterior:
package br.com.devfacil.view;
import br.com.devfacil.model.Pessoa;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SortListMain {
public static void main(String[] args) {
/**
* Cria lista de Pessoas
*/
List<Pessoa> listaPessoas = new ArrayList<Pessoa>();
/**
* Atribui 'Nome', 'Sobrenome' e 'Idade' fazendo uso do contrutor com
* parametros de Pessoa(String nome, String sobreNome, Integer idade);
*/
listaPessoas.add(new Pessoa("João", "da Silva", 41));
listaPessoas.add(new Pessoa("Ana", "Dias", 40));
listaPessoas.add(new Pessoa("Pedro", "Serafim", 30));
listaPessoas.add(new Pessoa("Maria", "Cavalcante", 58));
listaPessoas.add(new Pessoa("Beatriz", "Silva", 27));
Collections.sort(listaPessoas);
for (Pessoa p : listaPessoas) {
System.out.println("Nome: " + p.getNome() + ", Sobrenome: " + p.getSobreNome() + ", Idade: " + p.getIdade());
}
}
}
Note que na linha que tenta ordenar a lista Collections.sort(listaPessoas); o Java retorna um erro, falando, em linhas gerais, que não consegue ordenar uma lista de objetos do tipo Pessoa, porque não conhece os parâmetros de comparação necessários para ordenar os objetos; em outras palavras, a JVM não sabe se deve ordenar as pessoas da lista por nome, por sobrenome ou pela idade. Para solucionar este problema, nossa classe Pessoa deve implementar a interface Comparable, ou seja, 'ser comparável', e sobrescrever o metodo compareTo() da mesma, de modo que este possa determinar o que se deve levar em consideração para ordenar uma lista de pessoas. A nova classe Pessoa implementando Comparable é mostrada abaixo:
package br.com.devfacil.model;
public class Pessoa implements Comparable<Pessoa>{
private String nome;
private String sobreNome;
private Integer idade;
public Pessoa(String nome, String sobreNome, Integer idade) {
this.nome = nome;
this.sobreNome = sobreNome;
this.idade = idade;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getSobreNome() {
return sobreNome;
}
public void setSobreNome(String sobreNome) {
this.sobreNome = sobreNome;
}
public Integer getIdade() {
return idade;
}
public void setIdade(Integer idade) {
this.idade = idade;
}
@Override
public int compareTo(Pessoa pessoaComparacao) {
int idadeComparacao = ((Pessoa) pessoaComparacao).getIdade();
/**
* Ordena as idades de forma Crescente
*/
return this.idade - idadeComparacao;
}
}
Note que o método compareTo() recebe um objeto pessoa e compara o atributo idade, dos objetos. Ao executar o metodo main() da classe principal novamente, o erro desaparece, e a saída do programa é a seguinte:
As pessoas da lista estão ordenadas com a idade em valores crescentes. Como exemplo, podemos alterar o metodo compareTo() do objeto Pessoa, de modo a obtermos a ordenação em forma decrescente:
@Override
public int compareTo(Pessoa pessoaComparacao) {
int idadeComparacao = ((Pessoa) pessoaComparacao).getIdade();
/**
* Ordena as idades de forma Descrescente
*/
return idadeComparacao - this.idade;
}
Trabalhar com listas e vetores (arrays) é vital para qualquer linguagem de programação. A linguagem Java possui a poderosíssima API Collections, que nos ajuda a trabalhar com listas, e entre outras funcionalidades bastante interessantes, nos permite ordená-las.
Ordenando uma lista Simples
Começaremos com um exemplo básico: Uma lista de nomes, cujos valores são adicionados aleatoriamente;
/**
* Lista de String's contendo nomes
*/
List<String> listaNomes = new ArrayList<String>();
listaNomes.add("Joaquim");
listaNomes.add("Pedro");
listaNomes.add("Ana");
listaNomes.add("Bianca");
listaNomes.add("Maria");
listaNomes.add("João");
/**
* FOR avançado: para cada String dentro de 'listaNomes' associamos a
* variável 'nome' e a exibimos na tela
*
* Exibe lista na ordem de adição
*/
for (String nome : listaNomes) {
System.out.println(nome);
}
A saída obtida ao executarmos este código, é a seguinte:
Joaquim
Pedro
Ana
Bianca
Maria
João
Usando o metodo estático sort() de java.util.Collections podemos facilmente ordenar esta lista de nomes. O código abaixo é exatamente igual ao anterior, porem adicionamos a chamada Collections.sort(listaNomes) :
/**
* Lista de String's contendo nomes
*/
List<String> listaNomes = new ArrayList<String>();
listaNomes.add("Joaquim");
listaNomes.add("Pedro");
listaNomes.add("Ana");
listaNomes.add("Bianca");
listaNomes.add("Maria");
listaNomes.add("João");
/**
* Chamada ao metodo sort()
* Ordena a lista em ordem alfabética;
*/
Collections.sort(listaNomes);
for (String nome : listaNomes) {
System.out.println(nome);
}
Ordenando um Vetor (Array)
Em JAVA, os vetores (arrays) também podem ser ordenados de forma bem semelhante:
String[] arrayNomes = new String[]{"Joaquim", "Pedro", "Ana", "Bianca", "Maria", "João"};
/**
* Exibe a lista de nomes
* na ordem que está colocada no vetor
*/
for (int i = 0; i < arrayNomes.length; i++) {
System.out.println(arrayNomes[i]);
}
System.out.println("\n");
/**
* Ordena os nomes do vetor
*/
Arrays.sort(arrayNomes);
/**
* Exibe a lista de nomes
* já ordenada
*/
for (int i = 0; i < arrayNomes.length; i++) {
System.out.println(arrayNomes[i]);
}
Ao tentar ajustar o papel de parete (wallpaper) por um de maior resolução, notei que a imagem se apresenta toda desconfigurada, com escala desproporcional à tela.
Depois de muito tentar e pesquisar na web aqui vai a solução:
Solução 1:
- Na janela terminal, execute a seguinte linha de comando:
sudo gsettings set org.gnome.desktop.background picture-options "scaled"
Onde a opção "scaled" pode ser substituida por: wallpaper, centered, stretched, scaled, zoom, spanned. Solução 2: - Certifique se que tens instalado dconf-editor executando o seguinte comando:
sudo apt-get install dconf-editor
Feito isto, execute o dconf-editor (que nada mais é que uma interface gráfica para ajustes de configurações gerais de seu ambiente Ubuntu) através do seguinte comando na janela do terminal:
dconf-editor
Nesta janela, navegue até org > gnome > desktop > background
Dê duplo clique em picture-options, e escolha a opção que melhor se adapte à sua necessidade: wallpaper, centered, stretched, scaled, zoom, spanned, através do menu pop-up que surge. É isso.