Java類集(一)

Collection接口的實現：

List接口

繼承自Collection接口，以下ArrayList爲實現類

public class ArrayList01demo {
 public static void main(String[] args) {
  List<String> alllistList=null;//定義List對象
  Collection<String> allCollection=null;//定義Collection


  alllistList=new ArrayList<String>();//實例化List對象，只能是String
  allCollection=new ArrayList<String>();//實例化Collection對象，只能是String


  alllistList.add("Hello");//從Collection繼承的方法
  alllistList.add(0,"world");//此方法爲List擴充的方法
  System.out.println(alllistList);//輸出集合內容


  allCollection.add("XYL");//增加數據
  allCollection.add("ruanjian163");//增加數據


  alllistList.addAll(allCollection);//從Collection繼承的方法，增加一組對象
  //alllistList.add(0,allCollection);//此方法List自定義的，增加一組對象
  System.out.println(alllistList);//輸出對象，調用toString()方法

 }

}

有增加的方法，那也有刪除的方法：

allList.remove(0);//刪除第一個元素，指定刪除位置

allList.remove(“Hello”);//此方法由Collection接口繼承而來

類集的輸出：

由前往後輸出：

for(int i=0;i<allList.size();i++){System.out.println(allList.get(i)) ;}

由後往前輸出：

for(int i=allList.size()-1;i>=0;i--){System.out.println(allList.get(i))}

對象的數組形式：

String str[]=allList.toArray(new String[] { });

for(int i=0;i<str.length;i++){System.out.print(str[i]+".")}

  Object obj []=allList.toArray();//返回Obj類型

  for(int i=0;i<obj.length;i++){

String temp=(String)obj[i];//進行向下轉型

System.out.println(temp);

}

集合中還有以下的幾個操作：

• 判斷集合是否爲空：boolean isEmpty();

• 截取部分集合：List subList(int fromIndex,int toIndex);//List接口擴充

• 查找指定的對象是否存在：int indexOf(Object o),如果查找對象存在則返回位置，否則返回-1

• 查找對象是否存在：boolean contains(Object o)

挽救的子類：Vector

雖然Vector類是舊的類，但是因爲讓其實現了List，所以對於程序來說是一樣的。

• 增加元素：public void addElment(E obj)->此方法是最早的增加元素的操作，之後此方法的功能與add()方法一致。但是需要注意的是，public void addElment(E obj)是基於Vector類實現的，ArrayList是不能使用該方法。

子類的差異：ArrayList與Vector的區別：

	ArrayList:	Vector
性能	採用異步處理方式，性能更高	採用同步處理方式，性能較低
線程安全	屬於非線程安全的操作類	屬於線程安全的操作類
輸出	只能使用Iterator,foreach輸出	可以使用Iterator,foreach，Enumeration輸出

LinkList類

LinkList表示的是一個鏈表的操作類，Queue接口是Collection的子接口

Queue接口定義的方法：

• public E element() :找到鏈表的表頭

• public boolean effer(E e):將指定元素增加到鏈表的結尾

• public E peel():找到但不刪除鏈表的表頭

• public E poll():找到並刪除鏈表的頭

• public E remove():檢索並移除表頭

LinkList本身大量的擴充了Queue接口和List接口，所以最好直接使用LinkList類完成操作

public class LinkListDemo {
 public static void main(String args[]) {
  LinkedList<String> linkedList=new LinkedList<String>();
  linkedList.add("A");//增加元素
  linkedList.add("B");//增加元素
  linkedList.add("C");//增加元素
  System.out.println("初始化鏈表"+linkedList);
     linkedList.addFirst("X");//在開頭增加元素
     linkedList.addLast("Y");//在結尾增加元素
     System.out.println("增加頭和尾之後的鏈表"+linkedList);
  System.out.println("element()方法找到表頭"+linkedList.element());
  System.out.println("poll()方法找到表頭"+linkedList.poll());
  System.out.println(linkedList);
 }
}

既然此類實現了Queue接口，那麼來說就可以按照隊列的方式進行FIFO的操作

for(int i=0;i<=link.size()+1;i++){
System.out.println(link.poll()+".")
}

set接口：

set接口也是Collection接口的子接口，但是與Collection或List接口不同的是，Set接口中不能存放重複的元素

set接口的主要方法與Collection是一致的

Set接口無法像List接口那樣進行雙向輸出

set接口的常用子類：
散列存放：HashSet

順序存放:TreeSet

public class HashSetDeMO {
 public static void main(String[] args) {
 Set<String> allSet=new HashSet<String>();
 allSet.add("A");//增加內容
 allSet.add("B");//增加內容
 allSet.add("C");//增加內容
 allSet.add("D");//增加內容
 allSet.add("E");//增加內容
 System.out.println(allSet);
 }
}

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo02 {

 public static void main(String[] args) {
  Set<Person> allSet=new TreeSet<Person>();
  allSet.add(new Person("張三", 30));
  allSet.add(new Person("李四", 31));
  allSet.add(new Person("王五", 32));
  allSet.add(new Person("王五", 32));
  allSet.add(new Person("趙六", 33));
  allSet.add(new Person("孫七", 33));
  System.out.println(allSet);
 }
}

class Person{
 private String name;
 private int age;
 public Person(String name,int age) {
  this.name=name;
  this.age=age;
 }
 public String gtoString(){
  return "姓名： "+this.name+";年齡： "+this.age;
 }
}

則出現了以下錯誤：

Exception in thread "main" java.lang.ClassCastException: Person cannot be cast to java.lang.Comparable
 at java.util.TreeMap.compare(TreeMap.java:1188)
 at java.util.TreeMap.put(TreeMap.java:531)
 at java.util.TreeSet.add(TreeSet.java:255)
 at TreeSetDemo02.main(TreeSetDemo02.java:9)

Comparable主要是進行排序的操作接口，一個對象數組想要排序，則依靠 Comparable接口完成，那麼TreeSet也一樣，如果想要TreeSet進行排序的操作，則對象所在的類也必須實現Comparable接口

import java.util.Set;
import java.util.TreeSet;
class Person implements Comparable<Person>{
 private String name;
 private int age;
 public Person(String name,int age) {
  this.name=name;
  this.age=age;
 }
 public String toString(){
  return "姓名： "+this.name+";年齡： "+this.age;
 }
 public int compareTo(Person per) {
  if (this.age>per.age) {
   return 1;
  }
  else if (this.age<per.age) {
   return -1;
  }
  else {
   return this.name.compareTo(per.name);//調用String中的compareTo方法
  }
 }
}

如果將TreeSet改爲HashSet,此時重複的元素並沒有消除，想要消除重複元素，則需要Object中的兩個方法

• HashCode():表示唯一的編碼，一般通過計算表示
• equals():進行對象的比較

public boolean equals(Object obj){//覆寫equals,完成對象的比較
if(this==obj){
return true;
}
if(!(obj instanceof Person)){
return false;
}
Person p=(Person)obj;//向下轉型

if(this.name.equals(p.name)&&this.age==p.age){
return true;
}
else{
return false;
}
}
public int hashCode(){
return this.name.hashCode()*this.age;       //定義一個公式
}

一個好的類應該覆寫Object類中的equals(),hashCode(),toString()三個方法，實際上在String中以及全部覆寫了完成了。

Set接口依靠hashCode()和equals()完成重複元素的判斷，這一點在日後的Map接口中也有體現

TreeSet依靠Comparable接口完成排序的操作

SortedSet接口

TreeSet類是可以排序的接口，TreeSet實際上也是SortedSet接口的一個子類，所以此接口的所有類都是可以排序的。

import java.util.SortedSet;
import java.util.TreeSet;
public class TreeSetDome5 {
 public static void main(String[] args) {
  SortedSet<String> allSet=new TreeSet<String>();
  allSet.add("A");//增加內容
  allSet.add("B");//增加內容
  allSet.add("C");//增加內容
  allSet.add("D");//增加內容
  allSet.add("E");//增加內容
        System.out.println("第一個元素"+allSet.first());
        System.out.println("最後一個元素"+allSet.last());
        System.out.println("headSet元素"+allSet.headSet("C"));
        System.out.println("tailSet元素"+allSet.tailSet("C"));
        System.out.println("subSet元素"+allSet.subSet("B", "D")); 
 }
}

Iterator接口

在集合的操作中支持以下幾種方式：

• Iterator
• ListIterator
• foreach輸出
• Enumeration
  集合輸出的標準操作：只要碰到了集合輸出的操作，一定要使用Iterator接口，因爲這是最標準的做法

Iterator接口的操作原理：
Iterator是專門的迭代輸出的接口，所謂迭代輸出就是把元素一個一個進行判斷，判斷其是否由內容，如果有內容，那就將其取出

對於Iterator而言，因爲其本身就是一個接口，所以想要實例化則必須依靠Collection接口完成(Iterator<E>iterator())

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorDemo01 {
 public static void main(String[] args) {
  List<String> all=new ArrayList<String>();
  all.add("Hello");
  all.add("_");
  all.add("world");
  Iterator<String> iterator=all.iterator();
  while (iterator.hasNext()) {
   System.out.println(iterator.next());
  }
 }
}

以上的操作代碼屬於Iterator的標準做法，Iterator提供了remove()方法，此方法功能是用於刪除當前對象

但在實際中，Itetator是很少調用刪除操作的，因爲其本身的功能就是輸出內容。List接口本身存在刪除方法:remove(),如果在迭代過程中使用了List的remove(obj)執行刪除操作，則代碼將出現問題，因爲在刪除之後，迭代將不會繼續執行。

Iterator接口的功能是從前往後輸出，屬於單向輸出

Iterator的主要功能就是完成迭代輸出操作的

在使用Iterator的時候最好不要刪除數據

ListIterator接口

Iterator接口的主要功能是由前向後單向輸出，而此時如果想實現由後向前或者由前向後的雙向輸出，則就必須使用Iterator的子接口—ListIterator

雖然此接口可以進行雙向的輸出，但是遺憾的是Collection接口中並沒有定義可以爲此類實例化的操作，只有List接口中才存在了ListIterator接口的實例化操作。
範例：完成雙向輸出：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;


public class ListIteratorDemo {
 public static void main(String[] args) {
  List<String> all=new ArrayList<String>();
  all.add("Hello");
  all.add("_");
  all.add("World");
  ListIterator<String> iterator=all.listIterator();
  System.out.println("由前向後輸出：");
  while (iterator.hasNext()) {
   String string=iterator.next();
   System.out.print(string+".");
  }
  System.out.println("由後向前輸出：");
  while (iterator.hasPrevious()) {
   String string=iterator.previous();
   System.out.print(string+".");
  }
 }
}

此時以及實現了從後向前的輸出操作。

但是，在使用此操作的時候一定注意一點，一定要先進行從前向後的輸出，之後才能進行從後向前的輸出

• 替換操作：iterator.set();

• 增加操作：iterator.add();