Java类集总结之一

1）类集：一个动态的对象数组，是对一些实现好的数据结构进行了包装。

　　类集框架的特性：高性能，对基本类集（动态数组、链接表、树和散列表）的实现是高效率的，所以一般很少需要人工去对这些“数据引擎”编写代码；

　　  　　　　　　　  框架必须允许不同类型的类集以相同的方式和高度互操作方式工作（对于任何对象所有的操作形式都是一样的，例如想向集合中增加元素，则一定是使

　　　　　　　　　　　　 用add（）方法，另外类集中的元素类型都是统一的，即一个集合中要么全是A类对象，要么全是B类对象）；

　　　　　　　　　　类集必须是容易扩展和修改的，为了实现这一目标，类集框架被设计成包含了一组标准的接口。 

2）在使用各个类集接口时，如果没有指定泛型，则肯定会出现警告信息，

此时，泛型将被擦除而全部使用Object接收。

3）类集框架本身不受对象数组长度的限制。

4）Collection接口

此接口使用了泛型，可以保证类集操作的安全性，避免发生ClassCastException。

Collection接口是单值存放的最大父接口。

5）在开发中，很少直接使用Collectioin接口进行开发，基本上都是使用其子类接口。

子类接口主要有

List：可以存放重复的内容

Set：不能存放重复的内容，所有重复内容靠hashCode()和equals()两个方法区分

Queue：队列接口

SortedSet：可以对集合中的数据进行排序

6）集合的标准输出：

迭代输出：Iterator接口

只要用到集合的输出操作，就一定使用Iterator接口。

使用Iterator迭代器可以用来查找、删除指定的元素。

7）Collection、Set、List接口都属于单值的操作，即每次只能操作一个对象，

而Map接口每次可以操作一对对象，即二元偶对象，Map中的每个元素都使用key  value

的形势存储在集合中。

8）Collections集合工具类

通过此类可以方便地操作集合，如替换、检索、排序等操作。

9）

package cn.itcast.arraylist.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ArrayListDemo {

    public static void main(String[] args) {
        List<String> allList = null;//定义List对象
        Collection<String> allCollection = null;//定义Collection对象
        allList = new ArrayList<String>();//实例化List对象，只能是String类型
        allCollection = new ArrayList<String>();///实例化Collection对象
        allList.add("Hello");//从Collection继承的方法
　　　　 allList.add("Hello");//List可以存放重复的内容
        allList.add(0,"Worldl");//List扩充的方法
        System.out.println(allList);//输出：[World,Hello]//
        allCollection.add("Lxh");
        allCollection.add("wwww");
        System.out.println(allCollection);
        allList.addAll(allCollection);//增加一组对象
        allList.addAll(0, allCollection);
        System.out.println(allList)；
    }
}

注：ArrayList是List的子类，直接通过对象的多态性为List实例化

List是Collection的子类，通过对象的多态性有ArrayList实例化。

顺序：Collection(接口)

List（接口）

ArrayList（子类）

注意：集合不是数组：

10）

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

public class ArrayListDemo03 {

    public static void main(String[] args) {
        List<String> allList = null;
        allList = new ArrayList();
        allList.add("Hello");
        allList.add("wwww");
        System.out.println(allList.size());//输出结果：2
        System.out.println(allList.get(0));//输出：Hello
        for(int i=0;i<allList.size();i++){
            System.out.println(allList.get(i));
        }
        String str[] = allList.toArray(new String[] {});//集合变数组
        System.out.println("数组输出");    
        for(int j=0;j<str.length;j++){
            System.out.println(str[j]);
        }
    }

}

11）

Set接口是Collection的子类，没有对Collection进行扩充，但是要求更严格，不能存放重复内容；当存入重复内容时，重复元素只增加一次。

Set接口的实例无法像List接口那样进行双向输出，因为此接口没有提供像List那样的get(int index)方法。

顺序：

Collection（接口）

Set（接口）

SortedSet(接口)、HashSet（子类）、TreeSet（子类）

HashSet里面不能存放重复元素，而且采用散列的存储方式，所以没有顺序，即输出是随机顺序。

12）

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo01 {

    public static void main(String[] args) {
        Set<String> allSet = new HashSet<String>();
        allSet.add("D");
        allSet.add("B");
        allSet.add("C");
        allSet.add("C");
        allSet.add("C");
        allSet.add("A");        
        allSet.add("E");
        System.out.print(allSet);
    }

}

13）但是，当HashSet中存放自定义的类，每个对象所在的类必须覆写Object类的hashCode()、equals()、toString() 3个方法。覆写这三个方法之后，才能实现无重复存放。

package cn.itcast.comparable.demo01;

14）

import java.util.HashSet;
import java.util.Set;

class Person {
    private String name;
    private int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object obj){
        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;
    }
    public String toString(){
        return "姓名"+this.name+":年龄"+this.age;
    }
}

public class RepeatHashSet {

    public static void main(String[] args){
        Set<Person> allSet = new HashSet<Person>();
        allSet.add(new Person("张三",20));
        allSet.add(new Person("李四",22));
        allSet.add(new Person("王五",20));
        allSet.add(new Person("赵六",20));
        allSet.add(new Person("孙七",22));
        allSet.add(new Person("王五",20));
        System.out.println(allSet);
        
    }
}

15）TreeSet类：对输入的数据进行有序排列，即在集合中插入数据时时没有顺序的，但是输出之后数据是有序的，所有TreeSet是排序的子类。

16）

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

public class TreeSetDemo01 {

    public static void main(String[] args) {
        Set<String> allSet = new TreeSet<String>();
        allSet.add("C");
        allSet.add("C");
        allSet.add("C");
        allSet.add("D");
        allSet.add("A");
        allSet.add("D");
        allSet.add("B");
        allSet.add("E");
        allSet.add("A");
        System.out.print(allSet);//输出结构：ABCDE
    }
}

17）如果要将自定义的类存入TreeSet中，TreeSet中的每个对象所在的类必须实现Comparable接口，并且在compareTo方法中指明是按照哪个属性进行比较的。

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

class Student implements Comparable<Student>{
    private int num;
    private String name;
    private int score;
    Student(String name,int num, int score ){
        this.num = num;
        this.name = name;
        this.score = score;
    }
    
    public String toString(){
        return num + "……"+name + "……" + score;
    }
    @Override
    public int compareTo(Student stu) {
        if(this.num>stu.num){
            return 1;
        }else if(this.num<stu.num){
            return -1;
        }else{
            return 0;
        }
    }
}

public class TreeSetDemo01 {

    public static void main(String[] args) {
        Set<Student> allSet = new TreeSet<Student>();
        
        allSet.add(new Student("zhangsan",20,70));
        allSet.add(new Student("wangwu",27,85));
        allSet.add(new Student("lisi",30,62));
        allSet.add(new Student("zhangsan",28,65));
        allSet.add(new Student("sunqi",25,92));
        allSet.add(new Student("wwww",26,65));
        
        Iterator<Student> it = allSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}