Otro Ejercicio de Java para practicar para el cetamen 3 de Programación Orientada a Objetos… Solo Tienen que hacer lo que les piden… Si no piden main y no piden testear la aplicación no lo hagan (Si les sobra tiempo pueden hacerlo).

Enunciado:

ALUMNO

ATRIBUTOS:

RUT: String (máximo 10, los primeros 8 son números, luego el “-” y finalmente un número o una letra)

 tipo:  int  (considerar  uso  de  las  siguientes  constantes
Alumno.ADJUNTO:1,Alumno.REGULAR:2, Alumno.RETIRADO:3)

 ciudad: String

 prestamos: ArrayList<Préstamo>

MÉTODOS:

• 
   Constructor sin parámetros
• 
   Constructor con parámetros (obviando los préstamos, que deben ser generados posteriormente)
• 
   Accesador para cada atributo
• 
   Mutador para cada atributo
• 
   Método de impresión
• 
   Método  addPrestamo,  que  reciba  como  parámetro  un  objeto  del tipo Préstamo ya inicializado.
• 
   Método booleano isResponsable, que devuelve true si los tres últimos  préstamos  han  sido  devueltos  en  la  fecha  que corresponde,  false  en  su  defecto,  o  si  no  existen  préstamos registrados.

PRÉSTAMO

ATRIBUTOS:

fechaPréstamo: date

fechaDevolución: date (no puede ser inferior a la fecha de
préstamo).

libro: String

atrasado: boolean

MÉTODOS:

• 
  Constructor sin parámetros
• 
  Constructor con parámetros (que reciba todos los atributos, siendo atrasado: false)
• 
  Accesador para cada atributo
• 
  Mutador para cada atributo, excepto para el caso del atributo atrasado.
• 
  Método de impresión
• 
  Método devolverLibro() que recibe la fecha efectiva de la devolución y si es mayor a la fecha en la que debía ser devuelto el libro entonces deja el atributo atrasado seteado en true.

Todas  las reglas de negocio deben controlarse con
Excepciones.(Considerar lanzar objetos Exception para el tipo
numérico y para el tipo String por separado, explicando en el
mensaje la regla de negocio no cumplida).

Descarga Código de fuente:
http://estebanfuentealba.net/ayudantia/PreparandoCertamen3EjercicioDos.rar

PD: Si quieren Testear El programa aqui les dejo un Main

/**
 * @(#)EjercicioDos.java
 *
 * EjercicioDos application
 *
 * @author Esteban Fuentealba
 * @version 1.00 2009/11/28
 */
import cl.duoc.pef.ejerciciodos.entidades.*;
import cl.duoc.pef.ejerciciodos.exception.*;
import java.util.*;
public class EjercicioDos {

    public static void main(String[] args) {
    	try {
	    	Carrera c = new Carrera("Informatica",(byte)4,true);

	    	Alumno alumnoA = new Alumno("11111111-1",Alumno.REGULAR,"Concepcion");
	    		Prestamo prestamoA = new Prestamo(new Date(2009,6,20),new Date(2009,6,25),"POO Avanzada");
	    		Prestamo prestamoB = new Prestamo(new Date(2009,7,20),new Date(2009,8,25),"Programacion para Principiantes");
	    		Prestamo prestamoC = new Prestamo(new Date(2009,9,20),new Date(2009,9,25),"Como  salir de la Depresión");
	    	alumnoA.addPrestamo(prestamoA);
	    	alumnoA.addPrestamo(prestamoB);
	    	alumnoA.addPrestamo(prestamoC);

	    	Alumno alumnoB = new Alumno("22222222-2",Alumno.ADJUNTO,"Concepcion");
	    		Prestamo prestamoD = new Prestamo(new Date(2009,7,20),new Date(2009,11,25),"Revista caras");
	    	alumnoB.addPrestamo(prestamoD);
	    	Alumno alumnoC = new Alumno("33333333-3",Alumno.REGULAR,"Concepcion");
	    	Alumno alumnoD = new Alumno("44444444-4",Alumno.RETIRADO,"Santiago");

	    	c.addAlumno(alumnoA);
	    	c.addAlumno(alumnoB);
	    	c.addAlumno(alumnoC);
	    	c.addAlumno(alumnoD);

	    	c.imprimir();
	    	prestamoB.devolverLibro(new Date(2010,0,0));
	    	System.out.println("Responsable: "+alumnoA.isResponsable());
    	} catch(NumberException exA) {
    		System.out.println(exA.getMessage());
    	} catch(StringException exB) {
    		System.out.println(exB.getMessage());
    	} catch(Exception exC) {
    		System.out.println(exC.getMessage());
    	}
   	}
}

Saludos!

Dentro de nuestros programas siempre habrá algun pedazo de código donde utilicemos arreglos.
Mientras implementaba unos métodos para insertar y eliminar registros de una clase, noté que en algunos había utilizado Arrays y en otros Lists. Por ello decidí buscar que es lo que recomendaban otros programadores al respecto, fue así como encontré este artículo.

Finalmente quede convencido de utilizar Lists debido a la flexibilidad que ofrecen.

Ejemplo:

public static void insert(List<Dato> datos) {
  //... configuracion de conexion
  for(Dato dato:datos){
	db.executeUpdate("insert into datos(desc,cantidad) values(:desc,:cantidad)",
	new Object[]{dato.getDescripcion(),dato.getCantidad()});
  }
}

VS.

public static void insert(Dato[] datos) {
  //... configuracion de conexion
  for(Dato dato:datos){
	db.executeUpdate("insert into datos(desc,cantidad) values(:desc,:cantidad)",
	new Object[]{dato.getDescripcion(),dato.getCantidad()});
  }
}

Como puedes observar, es prácticamente lo mismo, la diferencia es que al invocar el primer método puedes pasar como párametro un ArrayList, LinkedList, Vector o tu propia clase que implemente la interfaz List .

byte!

Compare two ArrayLists and remove all matches. I use this for example to remove stop words from search phrases or when i generate keywords programmatically!

Public Function RemoveMatches(ByVal alOriginal As ArrayList, ByVal alMatches As ArrayList) As ArrayList
    Dim alArrayList As New ArrayList

    For Each objObject As Object In alOriginal
        If Not alMatches.Contains(objObject.ToString.ToLower) Then
            alArrayList.Add(objObject)
        End If
    Next

    alOriginal.Clear()
    alMatches.Clear()

    alArrayList.TrimToSize()
    Return alArrayList
End Function

ကြၽန္ေတာ္တို႔ array ေတြ ေၾကျငာတဲ႔ အခါမွာ integer array ေၾကျငာရင္ integer ပဲ သိမ္းလို႔ ရပါမယ္။ string array ဆိုရင္လည္း string ေတြပဲ သိမ္းမွာေပါ့။ ဒီလိုမဟုတ္ပဲ ကိုယ္ၾကိဳက္တဲ႔ data type ကို သိမ္းလို႔ ရခ်င္ရင္ေတာ့ object array ေဆာက္ေပးရပါတယ္။

object[] arr = new object[3];
arr[0] = 1;
arr[1] = 2.2;
arr[2] = "abcdefg";

အခုထိ ကြၽန္ေတာ္တို႔ သံုးခဲ႔တဲ႔ array ေတြရဲ႕ size ဟာ static size ျဖစ္ပါတယ္။ ကြၽန္ေတာ္တို႔ array ကို ၃ ခန္းေၾကျငာလိုက္ရင္ ၃ ခန္းထက္ပိုျပီး တန္ဖိုးထည့္လို႔ မရပါဘူး။ ကြၽန္ေတာ္တို႔ သံုးမယ့္ array ရဲ႕ size ကို dynamic size အျဖစ္သံုးခ်င္တယ္ ဆိုရင္ေတာ့ သီးျခားအေနနဲ႔ collection class ေတြကို သံုးၾကရမွာပါ။ ပထမဆံုးအေနနဲ႔ ArrayList Class အေၾကာင္း စေျပာပါ့မယ္။
ArrayList Class က array တစ္ခုလိုမ်ိဳး အလုပ္လုပ္ေပးပါတယ္။ သူက variant size ပါ။ စေၾကျငာခ်င္းခ်င္းမွာ ArrayList ရဲ႕ capacity က ၄ ခန္းယူထားေပးပါတယ္။ ကြၽန္ေတာ္တို႔ တန္ဖိုးထည့္ရင္းနဲ႔ ၄ခန္းျပည့္ျပီးလို႔ ေနာက္ထပ္ထပ္ထည့္တာနဲ႔ capacity က ၈ခန္းျဖစ္သြားမွာပါ။ ကိုယ္တကယ္ တန္ဖိုးထည့္ထားတဲ႔ အေရအတြက္ကိုေတာ့ count ဆိုတဲ႔ property ကေန ျပန္သိနိုင္ပါတယ္။ ArrayList က zero base index ျဖစ္ျပီးေတာ့ သူ႔ရဲ႕ index က integer type ပါ။ ArrayList ကလည္း object type လက္ခံတာျဖစ္တဲ႔ အတြက္ ကြၽန္ေတာ္တို႔ ၾကိဳက္တဲ႔ type ထည့္ေပးခြင့္ရွိပါတယ္။ example ေလးၾကည့္ရေအာင္။

using System;
using System.Collections;

class arraylistTest
{
    static void Main()
    {
        object[] arr = new object[3];
        arr[0] = 1;
        arr[1] = 2.2;
        arr[2] = "abcdefg";

        ArrayList ar = new ArrayList();
        ar.Add(1);
        ar.Add(9.456);
        ar.Add("ABC");
        ar.Add('Z');
        ar.Add(new arraylistTest());

        for (int i = 0; i < ar.Count; i++)
        {
            Console.WriteLine("{0}\t( {1} )", ar[i], ar[i].GetType());
        }
        Console.WriteLine("\nActual Size of your Array : " + ar.Count);
        Console.WriteLine("Total Capacity of your Array : " + ar.Capacity);
        Console.Read();
    }
}

Hashtable Class
Hashtable class ထဲမွာ key/value တြဲ႕ data ေတြ လက္ခံပါတယ္။ key/value အတြဲလိုက္ကို DictionaryEntry လို႔ေခၚပါေသးတယ္။ ArrayList မွာ ကြၽန္ေတာ္တို႔ index ကို integer type သံုးပါတယ္။ Hashtable မွာေတာ့ index ေထာက္ဖို႔အတြက္ key ကိုသံုးပါတယ္။ သူကလည္း object type ပါ၊ ဒါေၾကာင့္ ကြၽန္ေတာ္တို႔ ၾကိဳ႔က္တဲ႔ type နဲ႔ index ေထာက္လို႔ ရပါတယ္။ သိမ္းမယ့္ data ေတြကိုေတာ့ value အပိုင္းမွာ သိမ္းရပါတယ္။ သူလည္း object type ပါပဲ။ Hashtable ကလည္း ArrayList လိုပဲ size ကို dynamically increment လုပ္လို႔ ရပါတယ္။ Example ေလးၾကည့္ရေအာင္။

using System;
using System.Collections;
class arraylistTest
{
    static void Main()
    {
        Hashtable ht = new Hashtable();
        ht.Add("Name", "Sevenlamp");
        ht.Add("Address", "Yangon");
        ht.Add("Age", 28);

        foreach (DictionaryEntry de in ht)
        {
            Console.WriteLine("{0}\t\t: \t {1} ", de.Key, de.Value);
        }
        Console.WriteLine("\nThere are {0} element/s in your Hashtable Array", ht.Count);
        Console.Read();
    }
}

Sim isso mesmo, no lugar de “progredir” vamos “regredir” um pouco, por que não é sempre que podemos trabalhar com as melhores condições possíveis, muitas vezes também precisamos colocar a mão na sujeira e editar algum código um tanto quanto ultrapassado, que ainda trabalha com vetores.

Se você já trabalhou com vetores, mesmo que apenas na faculdade, deve saber que com eles não conseguimos manipular os dados incluindo ou excluindo, só conseguimos criar (e destruir).

Ex.: String[] meuVetor = new String[] {“A”, “B”, “C”, “D”, “E”};

Neste exemplo, criamos um vetor com 5 posições, até aqui tudo bem, podemos solicitar cada posição do vetor com a chamada meuVetor[n],  trocando “n” pela posição do vetor, é claro, no nosso caso de 0 a 4.

Mas e se for necessário, em tempo de execução, adicionar algum valor ao vetor? Não é possível fazer um “meuVetor.add()“, então como fazer?
Simples! Basta trabalhar com Array, List ou Collection e jogar esse vetor no lixo!
Mas e se a aplicação nos forçar a trabalhar com vetor, caso contrário seria necessário refazer todo o código?

Simples! Basta trabalhar com Array e converter para Vetor!
Como?

Vejamos o exemplo, em javanês:

ArrayList<String> meuArray = new ArrayList<String>();
String[] meuVetor = null;

for(int i = 0; i < 10; i++){
meuArray.add(“POSICAO: “ + i);
}

meuVetor = meuArray.toArray(new String[meuArray.size()]);

Explicando!

A primeira e segunda linha não tem segredo, ali estão sendo criadas nossas variáveis base, um ArrayList meuArray e um vetor String[] meuVetor.
O laço “for” também não tem muita complicação, de 0 até 9 ele está inserindo valores no Array.

Na ultima linha que a mágica acontece, vamos por partes:

Primeiro, estamos vazendo meuVetor = meuArray.toArray() este método (toArray) é da própria linguagem Java, e serve exatamente para isso que precisamos, ele prepara um Array para ser convertido em Vetor, mas este método sozinho não faz muita coisa, então precisamos informar o tipo de vetor que estamos querendo, no caso é um vetor de String, então dentro do toArray basta informar new String[n]. Mas que “n”? para criar um Vetor, precisamos informar a quantidade de posições que ele terá, e para conseguir esta façanha, basta invocar o método size() do meu Array, que devolve o tamanho do array, justamente o que precisamos para iniciar o Vetor!

Simples né?!
Boa sorte!

When I was training a model using 30 documents, the Java program allocated more than 700Mb memory and started to cause many memory page file swaps on my laptop which made the processing really slow and the computer almost not responding. Memory configurations of the Java program and my laptop are shown below.

Java program: -Xmx1G

Computer: 1.5Gb physical memory, 4.4Gb physical memory plus virtual memory (Windows XP Sp2)

After profiling with Yourkit 8.08, I found that a large ArrayList with 16384 items allocated and HashMaps (512 allocated items each) in that ArrayList were where most memory was consumed. The initial size of the ArrayList was set to 16384 but it had only about 5000 items after processing the 30 documents. The initial size of Hashmaps was set to 512 but many of them contained only a hundred of items. Similar situations were also found in FeatureRecord and DirFileReader. I have changed them to use a smaller initial size or the predefined size. Even if there will be a lot more documents to be processed in the future, these code has to be rewrite to work efficiently.

Related source files: WriteMalletInput.java, FeatureRecord.java, DirFileReader.java

Memory snapshot from Yourkit can ben found in Main_TrainingDescriptor.xml-2009-06-10-low-memory.rar

Filling a gridview with your appropriate data can be done through several ways (or is approach the better word?). the one which i think is the easiest is the following.

The case: I’m viewing an arraylist of custom objects in my datagridview, obj is the one i want to add and represents a row of my gridview.

So the gridview has one function that allows me to add rows manually:

dgGridview.Rows.Add(this.getValuesToAdd(obj));

This functions takes an object array, so I wrote a simple function, that takes my object and returns an object array:

private object[] getValuesToAdd(Object o)
{
    CustomObject co = (CustomObject)o;
    List<object> l = new List<object>(5);

    l.Add(co.name);
    l.Add(co.date);
    l.Add(co.xvalue);
    l.Add(co.yvalue);
    l.Add(co.zvalue);

    return l.ToArray();
}

Alternatively you can use a List object to ease the handling:

private object[] getValuesToAdd(Object o)
{
    CustomObject co = (CustomObject)o;
    object[] objects = { co.name, co.date, co.xvalue, co.yvalue, co.zvalue };

    return objects
}

To use this codesnippet you have to define the columns in the properties page of the datagridview, or set them by code,… but what for do we have visual studio?

That’s all and it’s working fine,but i think, the best way (what i think) is to use a dataset, populate it with the data, and set the datasource of the gridview to the dataset. When adding rows dynamically (e.g. on button click) it might work to add a new row to the dataset and rebind the datasource?

But I’m not very familiar with datasets and when starting the project i didn’t even know, that i’ll use a gridview…
so it’s possibly not the best solution, but ‘all roads lead to rome’ in softwaredevelopement. I know this should not be the attitude of a programmer, but real life is hard.

Today I needed to sort an ArrayList with custom objects. I googled a short time and found a bunch of solutions, like using a LinkedList instead of an ArrayList, or using IComparor. They all seemed pretty good, but a little too much work . So I ended up with IComparable, which I think is the easiest and fastest way.

It comes with

al.Sort();

which uses the IComparable implementation of each element, to sort my arraylist. If your it contains only basic data types, that’s all you need to sort your ArrayList. So far, so good, but my list contains objects from my custom class.

So I needed my class to implement IComparable, to tell the hardworking little man inside my notebook which field to use when comparing an object with another.

class myClass : IComparable
{
    private DateTime dt;
    private double v1;
    private double v2;

    //code omited

    public int CompareTo(object obj)
    {
        if (obj is myClass)
        {
            myClass temp = (myClass)obj;
            return this.Date.CompareTo(temp.Date);
        }
        else
        {
            throw new ArgumentException("object is not from type myClass");
        }
    }
}

Theres a full example on msdn: http://msdn.microsoft.com/en-us/library/system.icomparable.aspx

That’s it, within half a minute everything works fine, without the need of writing a Comparer or other exotic code.

Stötte på detta som var lite annorlunda än vad jag trodde. Skapande av en array i .NET skapar jag som:

System.Array arrayName;

Almost all basic java programmers have this doubt in his mind which one is best to use either Vector or ArrayList, Hashtable or HashMap. I don’t want to deviate this topic by evaluating the time required for insertions/deletions/modifications of data in each class instances. Just want to convey a main difference that’s enough for developers to use these classes in a better way. In Java, both the classes are similar from an API perspective but there has to be some differences. Let’s see below.

Vector

• Vector is thread safe, because vector objects are synchronized which means you can access vector objects from any number of threads at the same time without affecting its data.
• Due to the above reason, In performance wise Vector is slightly slower than ArrayList

ArrayList

• ArrayList is just opposite of Vector class. Its not thread safe, suppose if you are using ArrayList instances in multiple threads surely which leads to create some problems while accessing.
• ArrayList comes from Collection Framework family. So its easy to developers to convert in to any other datastructure formats.

According to me, when you are going to write code without threads it would be better to use ArrayList instead of Vector. Because this will improve your code performance. Anyway based on your requirements you can choose either Vector or ArrayList.

If you want to use/access ArrayList objects concurrently without affecting its data, its possible. In Java, an API is available to achieve this.

List asyncList = Collections.synchronizedList(new ArrayList());

Like Vector vs ArrayList, the same differences are applies to Hashtable vs HashMap respectively

Another confusion will occur while working with iBatis , when we need to do something like

where id in (100,101,102)

We can simply do it as like this.

where r.status = ‘A’
<dynamic >
<isNotNull property=”Clients”>
and c.id
<iterate property=”Clients” open=”IN (” close=”)” conjunction=”,”>
#Clients[]#
</iterate>
</isNotNull>
<isNotNull property=”SMT”>
and t.smt_id
<iterate property=”SMT” open=”IN (” close=”)” conjunction=”,”>
#SMT[]#
</iterate>
</isNotNull>
</dynamic>

where SMT and Clients are lists, which can be any lists,  that I put into the parameter map(here am passing java.util.HashMap as parameter map).

A classe ArrayList do Framework .NET imita a funcionalidade dos arrays convencionais e permite o redimensionamento dinâmico da coleção por meio dos métodos da classe. Em qualquer momento, uma ArrayList contém um certo número de elementos menos que ou igual à sua capacidade (o número de elementos atualmente reservador para a ArrayList).

Podemos manipular a capacidade de uma ArrayList por meio da propriedade Capacity. Se uma ArrayList precisa ser redimensionada, por padrão, sua Capacity é dobrada.

ArrayLists armazenam referências à objetos. Todas as classes .NET derivam da classe object. Isso quer dizer que uma ArrayList pode conter objetos de qualquer tipo.

Exemplo de como criar um ArrayList de inteiros e percorrê-lo usando o laço foreach.

static void Main(string[] args){

Console.WriteLine(“\n\nPressione uma tecla para sair…”);
Console.ReadKey();
}

The Important usage of showing an ArrayList as Array is when you used to pass arguments as arrays and not as ArrayList.

import java.util.ArrayList;

public class ArrayListToArray
{
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();

        //Add Elements
        al.add(new Integer(1));
        al.add(new Integer(10));
        al.add(new Integer(21));

        //Show contents
        System.out.println("Contents of Arraylist : " + al);

        //Get Array
        Object[] arr = al.toArray();

        //Print Array
        int sum = 0;
        for(Object x : arr)
        {
            System.out.println(x);
            sum += ((Integer)x).intValue(); //Converting object to int
        }

        System.out.println("Sum = " + sum);
    }
}

An ArrayList is another collection implementation.

import java.util.*;

public class ArrayListDemo
{
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        System.out.println("Initial Size Of ArrayList : " + al.size());

        //Add elements to array list
        al.add("i");
        al.add("h");
        al.add("u");
        al.add("m");
        al.add("a");
        al.add("n");
        al.add("o");
        al.add("i");
        al.add("d");
        al.add(".");
        al.add("s");

        System.out.println("Size of ArrayList after additions : "+ al.size());

        //Contsnt of ArrayList
        System.out.println("Contents of ArrayList : " + al);

        //Remove Elements From ArrayList
        al.remove(".");
        al.remove(6);

        //Contents of ArrayList after removal
        System.out.println("Size of arraylist after removal : " + al.size());
        System.out.println("Contents After Removal : " + al);
    }
}

public ArrayList resultSetToArrayList(ResultSet rs) throws SQLException{
ResultSetMetaData md = rs.getMetaData();
int columns = md.getColumnCount();
ArrayList results = new ArrayList();

while (rs.next()){
HashMap row = new HashMap();
results.add(row);
for(int i=1; i<=columns; i++){
row.put(md.getColumnName(i),rs.getObject(i));
}
}
return results;
}

The lab for monday is almost entirely the same as the DVD labs. Here I’ll post some minor bits we went over in lectures which might help a bit.

Switch Statements

These are handy for checking specific things like numbers’ equality. They are useful if you want to have menus and use numbers for imput and the like.

eg:

we have a menu that says ‘please enter a number to select an option’, which is stored in an int called choice:

println(“please enter a number to select an option: “);

int choice = readInt();

the syntac for switch is:

switch (expression){

case n:

method();

break;

case n+1:

method2();

break;

}

this checks if expression is equal to n, if not, n+1, and will keep going down the list. it will execute the methods inside the case: until it comes to break; which ends the statement.

SAVE / LOAD

as in the lectures:

save:

saveToFile(dvds, “DVDs.xml”);

in this case, what happens is the contents of dvds(which is an arrayList of type String) is saved in the file called DVDs.xml in the directory your project is saved in.

load:

dvds = (ArrayList<String>) readFromFile(“DVDs.xml”);

this overwrited the file dvds (which is an ArrayList<String>) with the contents of the file DVDs.xml in the project directory.

FOR:EACH LOOP

Watch out with these, in a for:each loop, you cycle through elements of an array, arraylist or whatever, but you cannot modify the contents of the thing you are cycling though. It actually gives you a copy of what is contained, not the file itself.

syntax:     for(type anyname: listname)

type: String, int, DVD, Song.

anyname: the name which you will refer to each element by.

listname: the exact name of the array/ArrayList.

eg:

public void listDVDs(){

for(String moo: dvds)

{    println(dvd);    }

}

This will pick the first element in the arrayList ‘dvds’ (which holds String names), which shall be refered to as moo, and then execute whatever is inside the curly brackets. in this case it prints them out.

If it held DVD types, this would print the names of the dvds:

public void listDVDs(){

for(DVD moo: dvds)

{   print( moo.getTitle() );    }

}

Because we would get each DVD object stored in the arrayList, and all its methods inside it too, like a normal for loop.

ITERATOR

Don’t entirely know much about these, just that they are ways of cycling through and altering elements in lists/sets. Similar to a for-loop but with it’s own methods.

import the use of it by using: import java.util.Iterator;

we create it by the following: (not sure on the capital or small ‘i’/'I’)

Iterator<Type> iteratorname = collection.iterator();

eg: Iterator<DVD> it = dvds.iterator();

this creates an iterator which can cycle through DVD objects, we will call it ‘it’, and it will be attached to the dvds arrayList collection.

this iterator has its own methods;

hasNext() – which returns a true/false if there is another element in the list.

and next() – which gets the next element.

used generally (for the moment) like this:

while(it.hasNext() )

{ it.next(); }

to print the name of the DVDs:

while(it.hasNext() )

{ println(it.next().getTitle() ); }

Next: HashSets and HastMaps

specific questions to chilloxk[-at-]hotmail(-dot-).COM

Smash.

// (Some things needed for the assignment)

if, for any reason,(hint) you need to access an array outside of a
class, you will need to create a method to access that method
(basically, you will need 2: one method (a getter) that returns the
full array, and another (another getter) that returns just the value
of the array that you want.

This is slightly complicated, I didn’t cop it till Mairead answered an
email I sent to her.

The reason you need to do this is simple:
-you create the array as PRIVATE, therefore it cannot be accessed
outside the CLASS it is created in.
-this means that all the elements are also PRIVATE.

So to access them, you need something like:

// will return the entire array
public String/int/double accessArray()
{
return String/int/double array[];
}

// will return the contents of ‘i’
public String/int/double accessArrayElement(int i)
{
return String/int/double array[i];
}

ArrayLists are some job.

You can do the exact same stuff as arrays, storing data wise, but you
don’t have to specify the size of the array initially.
Better because:
- save memory in the PC
- can’t fill it

creation:

ArrayList<String/TicketMachine/int/double> smash = new

Right now, on a basic level, arrays are fucking fantastic.
They are a way of storing data. The data they can store is predefined
by the creator. The size of the array is also predefined. Neither can they
be changed. The fact that the max size cannot be changed is where
arrays fall down, so that’s why we use ArrayLists. But you need to
understand arrays first.
How you create arrays:
String[] a = new String[5];
This creates an array, which can hold only Strings, it is of size 5.

int[] shit;
shit = new int[10];
The first creates the address block in memory, the second assigns the
size of 10. Mairead is mad for that shit.

Visualise it like so:
{ [] [] [] [] [] }
It starts at 0, so you could consider the element names are
{ a[0], a[1], a[2], a[3], a[4] }

Using for loops is really just about cycling through array’s elements.
It would be possible, if you wanted to assign all the values of the
int array equal to 0, to do this:
a[0] = 0;
a[1] = 0;
a[2] = 0;
a[3] = 0;
a[4] = 0;
But, as padraic kirwin says in maths, when u get to something of size
1000 it doesn’t make sense, that’s where for loops come in.
int[] smash = new int[1000]
// creates an array from  { smash[0], smash[1],… smash[999] }
for (int i = 0; i <= 999; i++)
{
a[i] = 0;
}
this makes all the elements in the array equal to 0.
why does this work? we’ll take it section by section.
the for loop is really a better structured while loop. when i write it
i think of it in 3 stages:
stage 1 = “int i = 0″, the initialisation stage
stage 2 = “i <= 999″, the while stage
stage 3 = “i++”, the finalisation stage
here, i provides a counter, but it’s also a way of accessing the array.

each pass of the loop, a[i] is accessed and made equal to 0.
because at the end of each loop, i++ is ‘done’, which means i is made
what it is currently plus 1. so after the nth pass of the loop, i ==
n.

so you could do different operations to it, such as:
a[i]  = a[i] + 1;
so this would make the value of a[i] equal to its current value, plus one.

a[i] = a[1] * [a2];
this would make the value of a[i], which of course will change each
time, be multiplied by the value of what is in element a[1] and a[2]

you might think ya whatever this is boring, which you are dead right.
The major thing about arrays is that you can store much more than
ints, chars or Strings, you can hold an entire class in each element
of the array,
which is great for storing things like records of information, etc.
when you store a class object in an array, all the methods and fields
can be accessed.
for instance: if we had a method called getName(), in a class Customer.
and we had an array that held customers:
Customer[] list = new Customer[5];
and this array was populated fully, as in it was full of customers:
Customer[0] = cust1;
..etc (cust1 would have to be already created)

we could find the name of the Customer in the Customer[] array, by doing:
Customer[0].getName();

this would mean, we could make a String value equal to this case, for
whatever reason:
String coolest = Customer[0].getName();

if this was in a for loop:
String coolest = Customer[i].getName();

when would you ever use that?

well imagine you wanted to get the name of the person in the array
with the highest balance:
(we need to assume that we have a getter method called getBalance)

public String getHighestBal()
{
int highestBal = 0;
String name = ” “;
// the reason you need to do that^, is because.. well I don’t know. i
think it just needs a value, if it is to be updated.
for (int i = 0; i < 5; i++)
{
if ( a[i].getBalance > highestBal )
{
highestBal = a[i].getBalance;
name = a[i].getName;
}
}
return name;
}
what happens:
- goes into a[i], which is initially a[0], and checks the Customer
object in there, checks if the balance is greater than the value we
created ‘highestBal’
if it is, makes the highestBal value equal to it.
then gets the name of the customer in this element of the array and
makes the ‘name’ String we created
goes back into the for loop until i is no longer less than 5, then the
return statement is carried out and it exits

Here is a very simple and efficient way to retrieve unique items from a java.util.List.

All you need to do is put all the items in the java.util.List into a java.util.Set and then create a new java.util.Listfrom the Set. Since a Set does not allow duplicate entries, the new List created would only have the unique items.

Below is an example:
//the initial List
ArrayList list = new ArrayList();
list.add("ID_1");
list.add("ID_2");
list.add("ID_3);
list.add("ID_2); //duplicate entry - needs to be removed
//convert the List into a Set
Set set = new HashSet(list);
//create a new List from the Set
ArrayList uniqueList = new ArrayList(set);

Note that the order of the items in the unique list will not be the same as those in the original.
To maintain the order of the initial items use a java.util.LinkedHashSet instead of a java.util.HashSet.
To sort the items in the java.util.List use a java.util.TreeSet instead.

For further details, have a look here.