terça-feira, 11 de agosto de 2015

ACH2002 - Notas de Aula de outros professores ou de cursos semelhantes.



http://www.uspleste.usp.br/digiampietri/ACH2002/notasdeaula.html

http://www.ime.usp.br/~pf/analise_de_algoritmos/lectures.html
Postado por às Nenhum comentário:
Marcadores:

quinta-feira, 6 de agosto de 2015

ACH2002 - Introdução a Análise de Algoritmos - Assuntos

Diagrama:

-----
Postado por às Nenhum comentário:
Marcadores:

sexta-feira, 12 de junho de 2015

Ler arquivo texto com e sem definição do conjunto de caracteres

01 import java.io.*;
02 import java.nio.charset.*;
03 
04 public class Dump {
05    public static void main (String[] args) throws IOException {
06       FileInputStream fis;
07       try {
08          fis = new FileInputStream("t.txt");
09       } catch (FileNotFoundException e) {
10          System.out.println ("Arquivo t.txt nao encontrado.");
11          // se não encontrou então não abriu.
12          return;
13       }
14       InputStreamReader input = new InputStreamReader (fis, StandardCharsets.UTF_8); // decodifica para utf-8
15       //InputStreamReader input = new InputStreamReader (fis);
16       /*https://docs.oracle.com/javase/7/docs/api/java/nio/charset/StandardCharsets.html*/
17       /*http://en.wikipedia.org/wiki/UTF-8*/
18       int c;
19       try {
20          do {
21             c=input.read();
22             System.out.println (c);
23          } while (c>=0);
24       } catch (IOException e) {
25          System.out.println (e.getMessage());
26       } finally {
27          input.close();
28       }
29    }
30 } /*para ver o Ã§ e o Ã£*/
Java2html
Postado por às Nenhum comentário:
Marcadores: , ,

domingo, 7 de junho de 2015

Lista ligada

Uma lista ligada é uma coleção de nós (ou registros) em que cada um aponta (referencia) o próximo.
As operações que geralmente são executadas sobre uma lista ligada são inserção, remoção e busca. São as operações de dicionário.
Listas ligadas tem comprimento variável.
Sua tarefa é entender os métodos que inserem, removem e buscam.
Aqui está o código fonte:
https://drive.google.com/file/d/0B2aucTjhMlIVQWV6MDFLUHEwV2c/view?usp=sharing

Segue a listagem:
01 package Lista;
02 class No {
03    protected String chave, conteudo;
04    protected No prox;
05    No () {
06       chave=null;
07       conteudo=null;
08    }
09    No (String chave, String conteudo) {
10       this.chave= new String (chave);
11       this.conteudo= new String (conteudo);
12    }
13    String getChave () {
14       return new String (chave);
15    }
16    String getConteudo () {
17       return new String (conteudo);
18    }
19    No getProx () {
20       return prox;
21    }
22    void setChave (String chave) {
23       this.chave=new String (chave);
24    }
25    void setConteudo (String conteudo) {
26       this.conteudo=new String (conteudo);
27    }
28    void setProx (No prox) {
29       this.prox=prox;
30    }
31 }
Java2html

01 package Lista;
02 public class Lista {
03    protected No inicio;
04    public Lista () {
05       inicio=null;
06    }
07    public void insereNoInicio (String chave, String conteudo) {
08       No novoInicio=new No (chave, conteudo);
09       novoInicio.setProx (inicio);
10       inicio=novoInicio;
11    }
12    public void insereNoFinal (String chave, String conteudo) {
13       No aux=inicio;
14       if (aux==null) {
15          inicio=new No (chave, conteudo);
16       } else {
17          while (aux.getProx()!=null)
18             aux=aux.getProx();
19          aux.setProx (new No (chave, conteudo));
20       }
21    }
22    public String busca (String chave) {
23       // retorna o conteúdo
24       No aux=inicio;
25       while ((aux!=null) && (!chave.equals(aux.getChave())))
26          aux=aux.getProx();
27       if (aux!=null) return aux.getConteudo();
28       return null;
29    }
30    public boolean remove (String chave) {
31       No aux=inicio;
32       if (aux==null) {
33          //throw EmptyListException();
34          System.out.println ("Erro: tentou remover de lista vazia");
35       } else {
36          if (chave.equals(aux.getChave())) {
37             // eh o primeiro que tem que ser removido.
38             inicio=inicio.getProx();
39             return true;
40          }
41          while ((aux.getProx()!=null) && (!chave.equals(aux.getProx().getChave())))
42             aux=aux.getProx();
43          if (aux.getProx()!=null) {
44             aux.setProx(aux.getProx().getProx());
45             return true;
46          }
47       }
48       return false;
49    }
50    public boolean isEmpty () {
51       return inicio==null;
52    }
53    public void imprime () {
54       No aux=inicio;
55       if (isEmpty()) {
56          System.out.println ("Lista Vazia");
57       } else {
58          System.out.println ("{");
59          while (aux!=null) {
60             System.out.println ("    {" + aux.getChave() + "," + aux.getConteudo () + "}");
61             aux=aux.getProx();
62          }
63          System.out.println ("}");
64       }
65    }
66 }
67 
68 /*
69 class EmptyListException () {
70 }
71 */
Java2html
Postado por às Nenhum comentário:
Marcadores: , ,

Leitura e escrita

A leitura e escrita de arquivos é implementada por classes no pacote Java.io. Com essas classes pode-se usar pipes (são arquivos criados em memória para que processos executados no mesmo computador comuniquem-se - o sistema operacional pode ou não dar suporte a pipes).

Caso o sistema operacional emule arquivos de rede como arquivos locais (por exemplo o compartilhamento de drives do Windows e o Network File System no Linux), esse pacote pode também ser usado, reforçando, porque o sistema operacional apresenta um arquivo remoto como se fosse local.

Há diversos outros pacotes que tratam outros tipos de entrada e saída:
  • HTTP o pacote é javax.swing.text.html
  • imagens o pacote é javax.imageio.stream
  • rede e sockets o pacote é java.nio.channels
A hierarquia de classes de java.io é grande. Uma parte dela é apresentada no diagrama abaixo:























Observe o padrão decorator:

  • InputStream é o componente, FileInputStream é a implementação e ObjectInputStream é o decorador;
  • Reader é o componente, InputStreamReader é a implementação e BufferedReader é o decorador.
Tarefa:
    Crie um programa que lê um arquivo texto e o imprime na tela.
Postado por às Nenhum comentário:
Marcadores: , ,

Exemplo - decorator

código fonte zipado aqui.
01 /** Esta Ã© a classe (abstrata) básica.
02     Escolhi este porque creio ser o caso mais simples.
03 */
04 interface Basico {
05    /** Nas classes concretas descreve o modelo, 
06        nos decoradores acrescenta algo.
07    */
08    public String getDescription();
09    /** Nas classes concretas retorna o custo,
10        nos decoradores, inclui o custo da decoração
11       e retorna o custo.
12    */
13    public double getCost();
14 }
Java2html
01 /** Primeiro dos dois modelos básicos que pretendo implementar.
02 */
03 public class Modelo1 implements Basico {
04    /** Nas classes concretas descreve o modelo, 
05        nos decoradores acrescenta algo.
06    */
07    public String getDescription() {
08       return "Carroceria";
09    }
10    /** Nas classes concretas retorna o custo,
11        nos decoradores, inclui o custo da decoração
12       e retorna o custo. Caso valores precisem ser
13       exatos, sem truncar nem arredondar, Ã© melhor
14       usar int e codificá-los em centavos.
15    */
16    public double getCost() {
17       return 10000.00;
18    }
19 }
Java2html
01 /** Decorador.
02 */
03 public class Ar implements Basico {
04    /** Nas classes concretas descreve o modelo, 
05        nos decoradores acrescenta algo.
06    */
07    Basico b;
08    Ar (Basico b) {
09       this.b=b;
10    }
11    public String getDescription() {
12       return b.getDescription() + " Ar-condicionado";
13    }
14    /** Nas classes concretas retorna o custo,
15        nos decoradores, inclui o custo da decoração
16       e retorna o custo. Caso valores precisem ser
17       exatos, sem truncar nem arredondar, Ã© melhor
18       usar int e codificá-los em centavos.
19    */
20    public double getCost() {
21       return b.getCost() + 3500.00;
22    }
23 }
Java2html
01 /** Decorador.
02 */
03 public class Direcao implements Basico {
04    /** Nas classes concretas descreve o modelo, 
05        nos decoradores acrescenta algo.
06    */
07    Basico b;
08    Direcao (Basico b) {
09       this.b=b;
10    }
11    public String getDescription() {
12       return b.getDescription() + " Direção Eletro-assistida";
13    }
14    /** Nas classes concretas retorna o custo,
15        nos decoradores, inclui o custo da decoração
16       e retorna o custo. Caso valores precisem ser
17       exatos, sem truncar nem arredondar, Ã© melhor
18       usar int e codificá-los em centavos.
19    */
20    public double getCost() {
21       return b.getCost() + 2000.00;
22    }
23 }
Java2html
01 /** Decorador.
02 */
03 public class DVDplayer implements Basico {
04    /** Nas classes concretas descreve o modelo, 
05        nos decoradores acrescenta algo.
06    */
07    Basico b;
08    DVDplayer (Basico b) {
09       this.b=b;
10    }
11    public String getDescription() {
12       return b.getDescription() + " DVD player";
13    }
14    /** Nas classes concretas retorna o custo,
15        nos decoradores, inclui o custo da decoração
16       e retorna o custo. Caso valores precisem ser
17       exatos, sem truncar nem arredondar, Ã© melhor
18       usar int e codificá-los em centavos.
19    */
20    public double getCost() {
21       return b.getCost() + 800.00;
22    }
23 }
Java2html
01 class TestaDecorador {
02    public static void main (String[] args) {
03       Basico b = new Modelo1();
04       System.out.println (b.getCost());
05       Basico c = new Ar(new Modelo1());
06       System.out.println (c.getDescription());
07       Basico d = new Direcao(new Ar(new Modelo1()));
08       System.out.println (d.getDescription());
09    }
10 }
Java2html
Postado por às Nenhum comentário:
Marcadores: , ,

sábado, 6 de junho de 2015

Decorator

Decorator é um "padrão de projeto" (design pattern). Não tem nada a ver com uma norma, é uma forma de arranjar classes de forma a obter certa funcionalidade.

Este padrão permite estender (ampliar ou modificar) funcionalidades em tempo de execução. Em comparação com herança, reduz o número de subclasses para implementar as mesmas variações de funcionalidades.

É extensivamente usado no pacote java.io.

Decorator é construído a partir de uma classe (em geral interface ou classe abstrata) que define os métodos que existem tanto nas classes concretas quanto nos decoradores. As classes concretas implementam a funcionalidade básica que ainda não o foram na superclasse. Os decoradores contém (em geral como atributo), instâncias das classes concretas e estendem a funcionalidade invocando os métodos da classe concreta e acrescentando algo quando necessário. A relação básica entre as classes é ilustrada abaixo.
















 Exemplos deixarão isto mais claro.
Postado por às Nenhum comentário:
Marcadores: , ,
Assinar: Postagens (Atom)