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接口扩充

  扫描二维码关注公众号，回复： 8655234 查看本文章

• 查找指定的对象是否存在：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();