Vou apresentar-lhes a forma mais simples de pesquisa (e mais utilizada), em outros posts posso falar sobre as classes de pesquisa mais avançadas ou você mesmo pode procurá-las depois de possuir o conhecimento inicial.

Mapa e Árvore (HashMap e TreeMap).

Um mapa, na linguagem Java, consiste em literalmente um mapa de objetos, ou seja, você cria um mapa indicando onde seus objetos estão na lista, outro exemplo que podemos utilizar é o índice de um livro, que diz em que página está determinado asunto. Você irá fazer o mesmo, mas indicando em uma lista a posição de cada objeto:

O objeto XYZ está na posição 7 da lista.

Mas você não precisa fazer todo esse mapeamento sozinho, você precisa apenas mostrar o caminho e o java se vira com o mapeamento.
Depois que o mapa estiver pronto, você só precisa falar para o Java:

Ô rapaz, me da o objeto XYZ.

E você receberá o objeto xyz.

As classes HashMap e TreeMap no básico são identicas, funcionam da mesma forma, a diferença é que a árvore possui alguns métodos a mais, como identificar o primeiro ou o último item da lista, fazer submapas (tipo substring), enfim, tem algumas funções a mais, porém a pesquisa, para você, vai ser exatamente igual. Eu prefiro utilizar o HashMap porque ele costuma ser ligeiramente mais rápido.

Você precisará entender o concento de “chave/valor”, que é utilizado por todas essas classes de mapa, isso significa que cada objeto seu vai ter um identificador, um apelido, que você vai usar para “pedir” o objeto. Digamos que você tenha uma lista de um objeto do tipo Pessoa, essa classe, a classe Pessoa, possui os atributos nome, idade, cidade, cpf, profissão. Agora pense em como você usaria a frase “Me dá o objeto XXX”, para uma lista de Pessoa. Não dá né?
A única coisa que você pode fazer é pedir o objeto que está em determinada posição da lista, ou no nosso exemplo do livro, o texto que está na página 50. Dessa forma você precisaria saber o que existe em cada página ou ler todas as páginas para identificar o texto que você precisa.
Quando definimos um apelido para os objetos (e preparamos um mapa) a coisa fica mais fácil, mas devemos ter muito cuidado, vou repetir, devemos ter muito cuidado.
É necessário utilizar para apelido, algum valor que nunca, jamais, nem em um milhão de anos, se repetirá na lista, se por algum motivo você inserir algum objeto cujo “apelido” já exista na lista, o objeto antigo será eliminado e será considerado apenas o novo item. Isso vale para o HashMap e para o TreeMap.

Agora que você já entendeu o conceito de “chave/valor” ou seja, “apelido/objeto”, podemos criar o nosso mapa de Pessoa, mas precisamos escolher qual será o apelido de cada uma das Pessoas da lista. Tem que ser algo que não se repita. Que tal o CPF?

Criação do mapa:

Map<Long, Pessoa> mapa = new HashMap<Long, Pessoa>();

Para adicionar itens no mapa, utilizamos a função PUT, e passamos obviamente a chave (apelido) e depois o valor (objeto), vejamos alguns exemplos:

mapa.put(pessoa.getCpf(), pessoa);
mapa.put(11122233344, pessoa);
mapa.put(Long.parseLong("11122233344"), pessoa);

O preenchimento do mapa ficaria em algum loop, da mesma forma que você cria suas listas atuamente, se você está lendo as informações de um arquivo (txt), e a cada linha do arquivo é criado um objeto Pessoa, que seria adicionado à uma lista, mas no lugar da lista você adiciona o objeto em um mapa.

Agora vem a parte legal, sempre que você quiser fazer qualquer coisa com qualquer objeto da lista, você não precisa mais ficar percorrendo a lista e verificando se o objeto atual é o que você precisa, agora que estamos trabalhando com mapa, você pode simplesmente trabalhar com o apelido do objeto que você precisa!

mapa.get(11122233344);

caso queira eliminar o objeto da lista

mapa.remove(11122233344);

Lembre-se apenas que o apelido informado deve ser exatamente igual ao apelido que existe na lista, caso contrário poderá ser exibido um erro.
Para evitarmos qualquer tipo de erro, como por exemplo o apelido não existir na lista, podemos utilizar a função containsKey(). Esse método presente em praticamente todas as classes de mapa, retorna um booleano, informando se o apelido existe ou não na lista, dessa forma conseguimos controlar e evitar erros.

if (mapa.containsKey(11122233344)) {
     pessoaSelecionada = mapa.get(11122233344);
}
if (mapa.containsKey(11122233344)) {
     mapa.remove(11122233344);
}

Facil?

O apelido dos seus objetos pode ser de qualquer tipo, desde que não seja um tipo primitivo. Você pode utilizar como apelido um Integer, Long, Double, até String. Só lembre-se de que os apelidos que você escolher não podem se repetir, ou você terá uma lista inconsistente.

Se quiser trabalhar com TreeMap, a utilização é identica, você só precisa mudar a declaração da variável para algo como:

TreeMap<Long, Pessoa> tree = new TreeMap<Long,Pessoa>();

O TreeMap possui métodos a mais que podem te ajudar de alguma forma, mas a inserção, pesquisa e remoção de conteúdo é identica ao HashMap, não fazendo diferença utilizar um ou outro para listas/funções mais simples.

>>  Ordenação simples (Números)

Collections.sort(o, new Comparator() {
    public int compare(Object x1, Object x2) {
        Pessoa p1 = (Pessoa) x1;
        Pessoa p2 = (Pessoa) x2;
        if (p1.getIdade() < p2.getIdade()) {
            return -1;
        } else if (p1.getIdade() > p2.getIdade()) {
            return 1;
        } else {
            return 0;
        }
    }
 });

>> Ordenação de String  (Lista de String, ou lista de objeto com String).

Collections.sort(o, new Comparator() {
    public int compare(Object x1, Object x2) {
        Pessoa p1 = (Pessoa) x1;
        Pessoa p2 = (Pessoa) x2;
        Collator.getInstance().compare(p1.getNome(), p2.getNome());
    }
 });

Se apenas o código não te ajudou muito e/ou se você deseja se aprofundar mais no assunto, dedique de 5 a 10 minutos ao texto abaixo, ou um pouco mais de tempo se quiser ir praticando os exemplos.

Enquanto estamos aprendendo a programar (se você seguiu todos os passos direito, antes de linguagem aprendeu lógica), vemos alguns algoritmos de ordenação, como quick sort e bubble sort. Também vemos algorítmos de pesquisa, como busca binária e busca linear. Mas depois que deixamos a lógica de lado e começamos a ver alguma linguagem de programação mais recentes, orientada a objetos, eventos, aspectos ou qualquer coisa do tipo, verificamos que esse tipo de algoritmo não é mais necessário, apenas em alguns casos muito específicos. Isso porque as linguagens de hoje em dia já possuem métodos e códigos muito mais rápidos e performáticos para essas situações.

Antes de mais nada, precisamos verificar se existe mesmo a necessidade de ordenar a lista na aplicação, afinal, essa lista veio de algum lugar, e se esse lugar for um banco de dados, é muito melhor fazer um “Order By” no banco do que passar essa tarefa para o java ou qualquer outra linguagem, não importa se o banco de dados é Oracle, Sql, MySql ou mesmo Mainframe, quase todos os banco de dados possuem um order by, até mesmo o finado Access.
Mas nem sempre podemos contar com um banco de dados, as vezes fazemos programas que lêem arquivos, ou recebem informações por socket, webservice ou até mesmo por digitação do usuário.
Quando precisamos ordenar uma lista que não vem de um banco de dados, ou por algum motivo qualquer o banco de dados não consegue/não pode ordenar a lista, então apelamos para a ordenação no java, mas tome muito cuidado, você não precisa criar um algorítimo para ordenar alguma coisa, a própria linguagem tem ferramentas de ordenação que com certeza serão muito melhores que qualquer algorítimo que eu ou você fizermos (já testei e por melhor que fosse meu algorítimo, o do java sempre era milissegundos mais rápido).

Você já ouviu falar em Comparator? E em Comparable? Acho que também não deve conhecer o Collator?

Pois bem, essas são algumas das classes java que nos auxiliam a ordenar uma lista, pode ser uma lista de tipos primitivos ou uma lista de um objeto qualquer, até mesmo uma lista de objetos diferentes, da para ordenar de tudo.

Em muitos lugares você vai ouvir “implemente a classe x e sobrescreva o método y”, mas eu não gosto de fazer isso, eu até faço algumas vezes, mas apenas quando é necessário e apenas quando existir um tipo de ordenação. Deixe-me ser mais claro, imagine que você tem um objeto pessoa, esse objeto tem os atributos nome, idade e cidade. Agora imagine que você tem uma lista de Pessoa (List<Pessoa>), e na sua aplicação o usuário pode escolher ordenação por nome ou por idade ou por cidade.
Para esse caso, se você deixar o seu objeto “comparável”, você vai ter que escolher apenas um atributo para ser a chave da ordenação. Para conseguir realizar os três tipos de ordenação você precisará fazer uma gambiarra ou criar outras classes que servem apenas para indicar que a ordenação agora vai ser por idade, ou por cidade.
Por isso que eu não implemento o comparador, só faço isso quando vou utilizá-lo outras vezes, o que quase nunca acontece.

Se eu não implemento o comparador, o que eu faço?
Eu crio o comparador na hora que eu mando o java ordenar.

Mais ou menos assim:

Java, ordena para mim essa lista e usa esse novo critério que estou definindo agora. (Igual o seu chefe falando com você).

Vamos as explicações práticas!
Primeiro você precisa ter uma lista, de preferencia preenchida.

List<Pessoa> p;

Depois você precisa chamar o método sort da classe java.util.Collections e passar para ele a sua lista.

Collections.sort(p);

Se o seu objeto já é “comparável” (veremos isso mais para frente), apenas isso basta, mas se o seu objeto é “normal”, possui apenas os atributos e métodos básicos que você mesmo criou, então será necessário informar para o sort qual parâmetro de ordenação você escolheu. Nesse ponto, você informa uma classe de comparação que você criou, ou cria os parametros na hora (o que eu costumo fazer).

 Collections.sort(p, new Comparator());

Até aqui está tranquilo? Entendendo tudo?
Mas se você escrever apenas isso vai dar um erro, dizendo que não da para instanciar a classe “Comparator“. Isso é verdade, mas nosso código não acabou ainda, como eu disse, precisamos criar os parametros de ordenação.
Imagine que criaremos um método alí dentro do sort.

Collections.sort(p, new Comparator() { });

Captou a mensagem? Agora precisamos escrever algum método dentro do new Comparator() { }.
Mas não pode ser um método qualquer, tem que ser o método compare, que é utilizado pelo Comparator para estabelecer os parâmetros de ordenação.

Collections.sort(o, new Comparator() {
    public int compare(Object x1, Object x2) {}
 });

Até aqui tudo entendido?
O método compare, da classe Comparator fala para o ordenador qual dos dois objetos recebidos é “maior” e qual é “menor“, isso você que define.
Agora é que a mágica vai acontecer, o compare recebe dois Objects, que podem (e vão) ser do tipo da sua lista, então você faz o “cast“, e compara as variáveis da forma como desejar. Mas calma que não é só isso. Repare no tipo do método compare, ele retorna um int! O que devemos retornar nesse caso?

Se o objeto 1 for MENOR que o objeto 2, então o retorno deve ser -1
Se o objeto 1 for MAIOR que o objeto 2, então o retorno deve ser 1
Senão (objetos iguais), então o retorno deve ser 0;

Guarde muito bem essas informações na sua memória, isso vai ser bem utilizado em praticamente todos os tipos de comparação.

Apenas imagine o seguinte, a posição dos números: … -3, -2, -1, 0, 1, 2, 3 …
Qual número está à esquerda? Obviamente o -1
Qual número está à direita? Novamente óbvio, o número 1
O zero está exatamente no meio dos dois, é “neutro“, não tem diferença.

Agora imagine os parâmetros: public int compare(Object x1, Object x2)
Pense agora em colocar esses objetos na ordem, o objeto menor fica à esquerda e o maior dica à direita (partindo do primeiro objeto).

O x1 é MENOR? Então ele deve ficar na esquerda, então devemos retornar -1.
O x1 é MAIOR? Então ele deve ficar na direita, então devemos retornar 1.

Entendeu?
Então vamos colocar em prática.

Collections.sort(o, new Comparator() {
    public int compare(Object x1, Object x2) {
        Pessoa p1 = (Pessoa) x1;
        Pessoa p2 = (Pessoa) x2;
        if (p1.getIdade() < p2.getIdade()) {
             return -1;
         } else if (p1.getIdade() > p2.getIdade()) {
             return 1;
         } else {
              return 0;
         }     }
 });

Pronto, o código é esse.
Achou simples? Eu acho que podemos complicar mais!

A comparação acima serve apenas para Números. E quando precisamos ordenar TEXTO, o que fazer?
Calma, calma, calma, não há necessidade de apelar para algorítimos, deixa o Java fazer o trabalho sujo para você.

Imagine o mesmo princípio da ordenação por número, nós preparamos o ambiente mas agora vamos deixar o “IF..ELSE” para outro infeliz fazer.
Esse outro infeliz seria o método compare da classe java.text.Collator, essa classe tem muitas utilidades e vários tipos de ordenação muito legais, mas por enquanto o que nos interessa é a ordenação de texto.
O método compare dessa classe funciona exatamente igual ao que fizemos acima, ele recebe dois objetos, para o nosso caso ele recebe duas Strings, e retorna -1, 0 ou 1, exatamente como explicado acima. Então o que devemos fazer é substituir o nosso “IF..ELSE” pelo pelo compare dessa classe.

Collections.sort(o, new Comparator() {
     public int compare(Object x1, Object x2) {
         Pessoa p1 = (Pessoa) x1;
         Pessoa p2 = (Pessoa) x2;
         Collator.getInstance().compare(p1.getNome(), p2.getNome());
     }
 });

Ficou até mais simples…
O que fizemos aqui foi passar a Decisão para outra pessoa (Igual o seu chefe faz com você), no lugar de nós tomarmos a decisão de qual String é maior do que a outra, passamos essa tarefa para o método compare da classe Collator.

Isso é tudo pessoal! Ou melhor, quase tudo.
Fiquei devendo falar das implementações, que eu raramente uso.
Primeiro devo dizer que é raro eu precisar ordenar uma lista, porque trabalhando com banco de dados essa tarefa obviamente não fica com o java, mas quando é necessário ordenar a lista no java dificilmente essa mesma lista precirá ser ordenada novamente, no mesmo modo em outro lugar, mas existem algumas ocasiões em que precisamos ordenar a mesma lista, da mesma forma, na tela a, depois na tela b, e na tela c, etç, etç. Para esses casos é chato, inviável e não recomendável utilizar a ordenação da forma como fiz acima, digo isso porque: Digamos que você fez essa ordenação em 5 lugares diferentes da aplicação, e aplicou esse mesmo código nos cinco lugares. Depois de alguns meses, quase na implantação do projeto, o cliente desiste da ordenação e diz que ficaria melhor de outra forma, então você volta e altera os parâmetros de ordenação, mas você não lembra mais todos os lugares em que a ordenação é realizada, ou pior, você não está mais no projeto, quem vai alterar o código é o novo estagiáro! A casa caiu, certamente alguma(s) das ordenações ficará da forma antiga, o que causará um erro ou insatisfação do cliente, ou os dois.

Pensando nisso, podemos deixar a nossa classe Comparável! Mas o que significa isso? Significa que deixamos uma “marca” na nossa classe, dizendo que ela pode ser ordenada!

Vamos voltar à classe Pessoa:

class Pessoa {
     private String nome;
     privete String cidade;
     private int idade;
     //Getters e Setters
 }

Essa classe é simples, não tem nada de mais.
Podemos escolher um dos atributos para deixá-la comparável, no caso vou escolher o “mais facil”, onde o controle fica comigo, então vou escolher o inteiro, a idade.

Para marcarmos a classe informando que ela é “Comparável”:

class Pessoa implements Comparable<Pessoa> {}

Na declaração da classe acima, dizemos que a classe Pessoa é comparável com outra classe do tipo Pessoa.

Agora precisamos escrever um método chamado compareTo, que funcioana exatamente igual ao método compare que vimos acima, porém esse método recebe apenas um objeto, afinal o outro objeto é a própria classe.

public int compareTo(Pessoa p) {
     if (this.idade < p.getIdade()) {
         return -1;
     } else if (this.idade > p.getIdade()) {
         return 1;
     } else {
         return 0;
     }
 }

Como declaramos que a classe Pessoa é comparável com outro objeto do tipo Pessoa, entõ o nosso método compareTo recebe um objeto Pessoa como parâmetro. Se não declararmos na classe o tipo de objeto de comparação, então nosso método compareTo deverá receber um Object, e dentro do método fazemos o cast.

Agora nossa classe está pronta e preparada para ser ordenada por idade, basta você chamar o Collections.sort e ordenar a lista, sem precisar informar nenhum comparador.

Collections.sort(lista);

Mas e se quisermos criar vários tipos de comparação? Então agora você precisará criar classes de comparação!
Crie um comparador para cada tipo de ordenação que quiser fazer.
No nosso exemplo, já preparamos a classe Pessoa para ser ordenada por idade, agora precisamos ordená-la por nome. Então criamos uma nova classe no nosso projeto e implementamos o java.util.Comparator, ao implementar essa classe você será obrigado a escrever o método compare e, adivinha? Ele funciona exatamente igual o primeiro compare que escrevemos, deve retornar -1, 0 ou 1.
Esse método vai receber dois objetos. Se você declarou o tipo do objeto na assinatura da classe, então o método vai receber o tipo que você refiniu, caso contrário ele vai receber dois Objects.

class ComparadorNome implements Comparator <Pessoa>{
     public int compare(Pessoa o1, Pessoa o2) {
         return Collator.getInstance().compare(o1.getNome(), o2.getNome());
     }
 }

Fácil?
Agora na hora de ordenar, você fala para o Java mais ou menos assim:

Java, querido amigo, eu quero que você ordene essa lista, eu sei que ela está preparada para ser ordenada por idade, mas eu quero que você utilize esse outro parâmetro que eu encontrei jogado por ali e achei legal.

Isso em código fica dessa forma:

 Collections.sort(lista, new ComparadorNome());

Eu optei por deixar a classe preparada para ser ordenada por idade e criar um comparador para nome, mas você pode fazer o contrário, pode fazer o que quiser, com as váriáveis que achar melhor! Agora você já pode ordenar uma lista utilizando o atributo que achar melhor, e quantos atributos quiser.

Se ficou alguma dúvida, ou algum código não funcionou (eu testei!), pergunta ai.

Depois de muito tempo, consegui finalmente finalizar o final dessa matéria, que aparentemente ficou dividida em três postagens (se esse post realmente for o último).

Nos capítulos anteriores você pode ver que muitas imagens pesadas e navegação voltada para o mouse impedem e muito a utilização de seu site, esses dois assuntos são bem genéricos, ou seja, eles abordam todo tipo de acessibilidade, pode ser deficiência física, motora, equipamento ruim, conexão ruim, celular, qualquer coisa que seja um impedimento para a navegação. A matéria a seguir também é um pouco genérica, na parte de tabelas, mas tem uma parte especial voltada quase que exclusivamente à deficientes visuais, onde me refiro aos leitores de tela.

Vamos começar com tabelas, se estava genérico até agora vamos continuar nesse rumo.
As tabelas no HTML são tão úteis quanto no excel, eu gosto de tabelas, utilizando as tags <table> fica muito mais fácil desenhar e organizar o layout de qualquer site, mas tem um problema, o uso excessivo de tabelas prejudica a navegação e o carregamento da tela.

Em alguns lugares onde ajudei a construir ou manter os sites, seus layouts eram construídos unicamente com tabelas, todo tipo de organização que você possa imaginar. Quer alinhar um item à direita? coloca em uma tabela. Quer escrever um contrato? Tabela neles! Quer organizar um menu, com submenu e sub-submenu? Tabelas e tabelas dentro de tabelas!

Esse tipo de escrita do código faz a página ficar mais lenta para carregar. No seu computador com processador de 16 núcleos 50GB de memória e navegador Chrome isso não vai acontecer, mas voltando à primeira parte dessa matéria, nem todo mundo possui a dádiva de possuir um ótimo navegador, e a maioria dos usuários um pouco mais leigos nem sabem o que é um “Firefox” e acham que “Chrome” deve ser alguma moda em Paris, essas pessoas usam a “internet” que vem no computador, e provavelmente nem sabem o que é atualização ou não se preocupam com isso. Não estou falando mal do navegador da Microsoft, nas últimas versões ele até que está bom, ainda não é melhor que o Chrome ou Firefox, mas está bom. O problema maior está nas versões mais antigas do navegador, como por exemplo a versão 6, que eu vejo em muitos computadores ainda.
Durante os anos os códigos Html, Css e Javascript foram sofrendo melhorias e alterações, e os próprios navegadores foram se modificando para conseguir ler melhor o código fonte escrito, mas isso aconteceu aos poucos.
O que eu quero dizer com esse monte de palavras amontoadas é que possivelmente uma boa parte de seus usuários estarão utilizando computadores antigos e/ou com hardware fraco e softwares tão fracos e antigos quanto a máquina, nesse tipo de situação quando escrevemos um site com várias tabelas dentro de tabelas dentro de tabelas dentro de tabelas, forçamos o navegador e o pobre processador do usuário a ler mais e mais código (desnecessário) deixando o carregamento da página mais pesado.

Como alternativa podemos abusar do CSS, não precisamos eliminar as tabelas do site, isso não é necessário, o problema é quando temos inúmeras tabelas dentro de inúmeras tabelas! Tente se limitar a 2 ou 3 níveis de <table>, mais que isso já começa a ser abuso. Use mais CSS, dessa forma você diminui alguns míseros Kb no tamanho final da sua página (letras no código fonte também contribuem para aumentar o “peso” da página sabia?) e também deixa a abertura da página mais rápida.

Pense nisso, e coloque em prática se for necessário.

Continuando no assunto mais mudando quase que completamente o foco, você sabe o que é um leitor de tela? (para entender melhor o leitor de tela é necessário que você leia antes as partes 1 e 2 dessa matéria).
É mais ou menos como o nome diz, um programa que lê a tela para você, mas ele não é totalmente automático, alguns até que são mais inteligentes, mas até eles dependem muito do usuário que está utilizando, usuário esse que ou é um deficiente visual ou um desenvolvedor tentando deixar o site mais acessível. Existem vários leitores de tela, alguns bons outros ruins, alguns grátis e outros que abusam da deficiência da pessoa e cobram uma pequena fortuna. No Brasil os mais famosos (ao menos os que mais li comentários) são o DOSVOX, NVDA e Virtual Vision.
Quando eu estava em projeto acessível utilizava o Virtual Vision para os testes e gostei muito dele, bem personalizável, não consegui me acostumar com o NVDA e nunca testei o DOSVOX, mas esse foi o meu caso, com você pode ser diferente.

Esses leitores de tela até que tentam ser mais inteligentes que os desenvolvedores, a maioria deles tenta ler em alguma ordem os sites mesmo que estes não sejam acessíveis e/ou estejam totalmente bagunçados, mas eles não fazem milagres e como eu disse, eles “tentam” ler o site.

Um leitor de tela não lê o site da mesma forma que você está lendo agora, até porque isso é muito difícil e inviável, tecnicamente. O leitor de tela pega o código fonte do site e navega por ele, loucura não é mesmo? Exibe o código fonte do seu site (botão direito do mouse) e tenta ler ou navegar por esse monte de letras e códigos.

Para ajudar os leitores de tela, podemos deixar nosso código fonte organizado, evitar lixos, não usar muitas tabelas, conforme mencionado acima, e principalmente, definir textos alternativos para TUDO!
Um texto alternativo é aquela caixinha de informação que aparece quando você para o mouse sobre algum objeto, essa caixinha não aparece apenas em botões ou links, ela pode aparecer em qualquer lugar, até mesmo em textos e tabelas, para definir esses textos alternativos você pode utilizar os atributos TITLE ou ALT, dependendo da tag ela pode possuir um, outro ou os dois atributos, ai você escolhe qual utilizar, mas sempre utilize a opção de textos alternativos.

Vamos à dois exemplos:
1 – Digamos que você escreveu um texto e colocou uma imagem no meio do texto, quando o leitor de tela passar por essa imagem ele vai falar para o usuário “pasta um barra pasta dois barra imagem ponto jota pê gê”, é isso que sua imagem representa? Acho que não. Se você definir um texto alternativo para essa imagem, o leitor de tela irá falar para o usuário o que você escreveu, por exemplo “Imagem que mostra um gato com cara de mal pulando sobre um bebe dormindo”. Eu sei que as vezes isso é um pouco chato e na maioria dos casos o texto não tem graça como a imagem, mas pense em seu leitor deficiente visual, ele vai ficar frustrado se o leitor de tela ser o caminho e o nome da imagem em todas as imagens que estiverem em seu site, se fosse comigo eu não voltaria mais.

2 – Imagine agora que você colocou um link qualquer no seu site, o leitor de tela vai falar para o usuário mais ou menos assim: “agá tê tê pê dois pontos barra barra dabliu dabliu dabliu ponto meu site ponto com barra alguma coisa barra outra coisa barra mais alguma coisa barra postagem que eu quero ponto aga tê eme ele”. Coisa feia né? As vezes nem da para entender. Imagina então se for uma URL abreviada, não da nem para saber para onde o link vai: “agá tê tê pê dois pontos barra barra migre ponto me barra sete xis nove pê ipsulon agá um erre zê”. O que é isso? Desse jeito fica difícil navegar. Lembre-se de colocar os textos alternativos! Fazendo isso, seja qual for o leitor de tela que o usuário utilizar, o leitor falará o texto alternativo que você escreveu, ou seja, o que é, pra que serve e pra onde vai aquele link, ex: “Link para o site tal, para a página que explica como os gatos ninjas destruirão a humanidade em dois mil e doze”.

Os leitores de tela, alem de precisarem de textos alternativos também precisam de uma boa ordem de navegação, não é obrigatório mas ajuda MUITO se você definir os principais “tabindex” do seu site (parte 2 da matéria), tente deixar como ordem de navegação primeiro o conteúdo, depois as propagandas, banners, menus, links, etç, etç, afinal se eu entrei no seu site é porque eu quero ver a matéria e não quantos parceiros você tem, pelo menos na maioria dos casos.

O texto já ficou grande mas acho que terminei por aqui, apenas lembre-se de deixar seu site acessível e mais uma vez, acessibilidade não significa apenas deficiência física, pode ser deficiência física, motora, visual, auditiva, máquina velha, conexão ruim, dispositivo portátil, etç, etç, etç.

Lembre-se sempre do pior caso possível, e boa sorte!

Estamos de mudança para um novo endereço, http://javaerro.blogspot.com, em breve este endereço, Code Error, deixará de existir.
Aos poucos todos os posts estão sendo migrados, artigos novos serão publicados apenas em Java Erro.

Assim que a migração for concluída, esse blog fará apenas o redirecionamento.

Devido a falta de tempo e pouca possibilidade de personalização do wordpress “gratis”, foi necessário escolher entre um servidor pago ou algum grátis que me atendesse melhor.

Se você adicionou esse blog em algum tipo de link ou favoritos, por favor, atualize o novo endereço.

ATENÇÃO: Aos poucos os links desse blog (wordpress) direcionarão para as páginas do novo endereço (blogspot), dessa forma, não se assuste quando algum link abrir o endereço “javaerro.blogspot.com”, porque todos os meus movimentos são friamente calculados.

Obrigado!

Mas como fazer para que a minha variável de controle no Java seja enxergada no javascript?

Na minha época de estagiário, eu certamente faria algo do tipo:
Deixa a variável de controle no Bean, adiciona um campo “inputtext” oculto no jsp e faz esse campo receber o valor da variável de controle, via javascript eu mando um getElementById pegar o valor desse campo e começo a utilizar.

Maravilha, gambiarra melhor que essa fica difícil de fazer, nem da vontade de mexer mais no código depois disso, deixa lá para as gerações futuras saberem quem fez essa maravilha de código.

Uma coisa que eu costumo dizer é: Para que ter o trabalho de fazer algo que já fizeram, e provavelmente melhor do que você?

O Tomahalk já faz algo do tipo sem precisar ficar colocando campo oculto na tela, não precisa se preocupar mais com essa gambiarra, se preocupe com as outras.

O que iremos fazer é utilizar um comando do tomahalk que pega uma variável qualquer do seu bean e passa o seu valor para uma variável global em javascript (a variável é global mas funciona apenas no jsp em que ela foi declarada). Para utilizar essa “poderosíssima” ferramenta, precisaremos primeiro importar a taglib necessária no jsp, mas não se desespere, se você está utilizando JSF é bem provável que possua esse jar no meio de sua pasta lib.

Importe a seguinte taglib (eu estou chamando apenas de “T” para economizar as teclas digitadas):

<%@ taglib uri="http://myfaces.apache.org/tomahawk" prefix="t"%>

Agora, em qualquer lugar de seu jsp, mas para ficar menos feio, próximo ao seu javascript, importe a variável que precisa utilizando o comando t:jsValueSet

<t:jsValueSet name="" value=""/>

Em NAME você precisa colocar o nome que essa variável terá no javascript, pode ser qualquer coisa, até sorveteDeChocolate, mas será muito mais agradável se colocar um nome que faça referência ao que ela representa.
Em VALUE você deve colocar a variável de seu bean.

Ex.: Digamos que eu tenha uma variável de controle em meu bean chamada controleMensagem, essa variável é booleana.

NOTA: Os nomes no Java e no javascript podem ser iguais, eu coloquei diferente para não confundir as coisas.

Feito isso, agora eu só preciso utilizar a variável no javascript:

if (exibeMensagem) {
alert("preencha direito o campo x!");
}

No exemplo acima eu estou utilizando minha variável dentro do IF, porque condiz com o exemplo que eu passei, mas você pode utilizar em qualquer outra situação dentro de qualquer javascript no jsp em que o jsValueSet foi declarado, a variável não precisa nem ser booleana, pode ser de qualquer tipo.

Espero que esse post ajude a eliminar muitas gambiarras em seu código!