黑马程序员——java基础---集合--Collection

——— android培训、java培训、期待与您交流！ ———

理解集合

所谓集合，就是存储对象的容器。集合类似于数组，两者的区别在于，数组在定义时就设置了长度，长度是不可变的。集合是可变长度的，不需要定义长度。数组可以存储基本类型和变量，集合只能存储变量，不能存储基本类型。

在java中集合框架的基础是Collection和Map接口。因为集合都是对信息的存取，所以操作都是增删改查，只是方法名不同。

Collection

Collection接口有两个子接口：List、Set

List和Set的区别：

List中元素以存放顺序排序。Set是无序的，以默认或自定义排序方式排序。

List中元素可以重复，Set中元素不可以重复。

List

List下属两个实现类：ArrayList、LinkedList

常见操作代码如下：

import java.util.*;

class ListDemo
{
public static void main(String[] args)
{
//ArrayList常用方法演示
ArrayListDemo();

//LinkedList常用方法演示
LinkedListDemo();

//Vector已过时，曾用方法演示
VectorDemo();
}

/**
* LinkedList: 数组结构，查询快，增删慢。
*/
public static void ArrayListDemo()
{
ArrayList al = new ArrayList();

al.add("java 01");
al.add("java 03");
al.add("java 02");

//在指定位置添加元素
al.add(1, "java 011");
System.out.println(al);

//删除指定位置的元素
al.remove(2);
System.out.println(al);
al.remove(1);
System.out.println(al);

//修改指定位置的元素
al.set(1,"java 02");
System.out.println(al);

//获取指定位置的元素
System.out.println(al.get(1));

//循环打印集合中的元素
for (Iterator i = al.iterator(); i.hasNext(); )
{
System.out.print(i.next());
}

//打印集合中该对象的索引
System.out.println("index = " + al.indexOf("java 02"));

al.add("java 03");
al.add("java 04");

//返回从索引x到y-1的子集合
List sub = al.subList(1,3);
System.out.println("subList = " + sub);

//Iterator的子接口ListIterator包含更多的方法，包括修改和添加
//Iterator接口不会在修改后遍历新的元素
for (ListIterator l = al.listIterator(); l.hasNext(); )
{
Object o = l.next();
if (o.equals("java 03"))
l.set("java 003");
l.remove();
System.out.println(al);
}
}

/**
* LinkedList: 链表结构，查询慢，增删快。
*/
public static void LinkedListDemo()
{
LinkedList ll = new LinkedList();

//向集合最前添加元素
//1.6版本中替换为offerFirst()、offerLast()
ll.addFirst("java01");
ll.addFirst("java02");
ll.addFirst("java03");
ll.addFirst("java04");
System.out.println(ll);

//向集合最后添加元素
ll.addLast("java01");
ll.addLast("java02");
ll.addLast("java03");
ll.addLast("java04");
ll.addLast("java05");
ll.addLast("java06");
System.out.println(ll);

//打印集合第一个元素
System.out.println(ll.getFirst()); //1.6版本中替换为peekFirst()，遇到空位返回null

//打印集合最后一个元素

System.out.println("打印集合最后一个元素");
System.out.println(ll.getLast());

//取出并删除集合中的第一个元素
System.out.println(ll);
System.out.println(ll.removeFirst()); //1.6版本中替换为pollFirst()，该方法在遇到空位时不抛出异常，而是返回null
System.out.println(ll);

//        while(!ll.isEmpty())
//        {
//            //顺序取出并删除集合中的元素，
//            System.out.print(ll.removeFirst());
//        }
System.out.println("");
while(!ll.isEmpty())
{
System.out.print(ll.pollFirst());
//倒序取出并删除集合中的元素，
System.out.print(ll.pollLast());
}
}
/**
* Vector：已过时，查询慢，增删慢。
*/
public static void VectorDemo()
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");

Enumeration e = v.elements();
while(e.hasMoreElements())
{
System.out.println(e.nextElement());
}
}
}

/* 输出结果为
---------------------------
[java 01, java 011, java 03, java 02]
[java 01, java 011, java 02]
[java 01, java 02]
[java 01, java 02]
java 02
java 01java 02index = 1
subList = [java 02, java 03]
[java 02, java 03, java 04]
[java 03, java 04]
[java 04]
[]
[java04, java03, java02, java01]
[java04, java03, java02, java01, java01, java02, java03, java04, java05, java06]

java04
打印集合最后一个元素
java06
[java04, java03, java02, java01, java01, java02, java03, java04, java05, java06]

java04
[java03, java02, java01, java01, java02, java03, java04, java05, java06]

java03java06java02java05java01java04java01java03java02nulljava01
java02
java03
java04
-------------------------
*/

Set

Set底层结构是Map

HashSet

TreeSet

HashSet

HashSet底层结构为哈希表，存储的数据通过哈希算法分区，查找时按区查找。HashSet通过equals()方法计算hashcode（哈希值）确定元素的唯一性。

class HashcodeDemo
{
public static void main(String[] args) throws Exception
{
Collection collection1 = new HashSet();

collection1.add(new Pair(1, 2));
collection1.add(new Pair(2, 3));
collection1.add(new Pair(3, 4));
collection1.add(new Pair(4, 5));
collection1.add(new Pair(5, 6));

collection1.add(new Pair(1, 2));

Pair p1 = new Pair(1, 2);
Pair p2 = new Pair(1, 2);

System.out.println(p1 == p2);
System.out.println(p1.getClass().getName());
System.out.println(p2.getClass().getName());

Class c = Pair.class;
Field f = c.getDeclaredField("a");
Field f1 = c.getDeclaredField("c");
System.out.println(f.get(p1));
}
}

/* 排序器
class Comp implements Comparator<Pair>
{
public int compare(Pair h1, Pair h2)
{
int a1 = h1.getA();
int a2 = h2.getA();

int b1 = h1.getB();
int b2 = h2.getB();

if (a1 == a2)
return b1 - b2;
return a1 - a2;
}
}
*/

//class Pair implements Comparable
class Pair
{
private int a;
private int b;
public int c = 3;

public Pair(int a, int b)
{
this.a = a;
this.b = b;
}

//  public int compareTo(Object obj)
//  {
//      Pair pair = (Pair)obj;
//
//      int a = pair.getA();
//      int b = pair.getB();
//
//      if (this.a == a)
//          return this.b - b;
//
//      return this.a - a;
//  }

public int hashCode()
{
return a * 0.1 + b * 10;
}

public boolean equals(Object obj)
{
if (obj.getClass().getName() != "Pair")
{
System.out.println("class");
return false;
}

Pair pair = (Pair)obj;

int a = pair.getA();
int b = pair.getB();

if (this.a == a && this.b == b)
return true;
else
return false;
}

public String toString()
{
return a + ", " + b;
}

public int getA()
{
return a;
}

public int getB()
{
return b;
}
}

TreeSet

TreeSet底层结构为二叉树，通过compareTo()或以Comparator接口的匿名实现为参数来确定元素的唯一性。

/**
* TreeSet 底层结构为二叉树
* 元素需要实现comparable接口，覆盖compareTo方法，
* 或集合自身继承Comparator比较器，
*/

class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new MyCompare1());

ts.add("111");
ts.add("2121");
ts.add("3");
ts.add("142555");
ts.add("1342121");

ts.add("635");

Iterator<String> i = ts.iterator();

while(i.hasNext())
{
String s = i.next();
System.out.println(s);
}
}
}

class MyCompare implements Comparator
{
public int compare(Object o1, Object o2)
{
Person p1 = (Person)o1;
Person p2 = (Person)o2;

int num = p1.getName().compareTo(p2.getName());
if (num == 0)
{
if (!(p1.getAge() == p2.getAge()))
return p1.getAge() - p2.getAge();

return -1;
}

return num;
}
}

class MyCompare1 implements Comparator<String>
{
public int compare(String s1, String s2)
{
int num = s2.length() - s1.length();
if (num==0)
{
num = s1.compareTo(s2);
}
return num;
}
}

class Person implements Comparable
{
private String name;
private int age;
Person(String name, int age)
{
this.name = name;
this.age = age;
}

public int compareTo(Object o)
{
if(o instanceof Person)
{
Person p = (Person)o;
if (!(p.age == this.age))
return p.age - this.age;
else
return  this.name.compareTo(p.name);
}
else
{
throw new RuntimeException("Wrong object: not for Student class.");
}
}

public int getAge()
{
return age;
}

public String getName()
{
return name;
}
}

因为操作都差不多，只是方法名不一样，具体操作方法参见官方api文档。