List接口与Set接口及其子类的详细用法。Collection接口简介。ArraList，LinkedList，Vector

（一）链表的特点：
（1）这种节点关系的处理操作，核心需要一个Node类（保存数据，设置引用）
（2）在进行链表数据的查找，删除的时候需要equals（）方法的支持。
在实际的开发中对于这些数据的使用都有一些共性的特点：存储进去而后取。
     
     
   （二）Java类集框架
   1 Collection集合接口  
 （1）具体内容
  在java的类集里面（java.util包）提供两个最为核心的操作接口：Collection，Map接口，
其中Collection接口的操作与之前编写链表操作的形式类似，每进行一次数据操作的时候只能对单个对象进行处理。
所以Collection是单个集合保存的最大父接口。 Collection接口定义如下：
public interface Collection<E>extends Iterable<E>
从jdk1.5开始发现Collection接口上追加有泛型应用，这样的直接好处就是可以避免了ClassCastException，里面的所有的
数据的保存类型应该是相同的。

Iterabl接口中有方法  +iterable():Iterable<T>
Collection接口中有方法   public boolean add(E e)//向集合中添加数据
                        public boolean addAll(Collection<?extends E>c)//向集合中添加一组数据
                        public void clear() //清空集合数据
                        public boolean contains(Object o) //查找数据是否存在，需要使用equals（）
                        public boolean remove(Object o)//删除数据，需要equals方法
                        public int size()//取得集合长度
                        public Object[] toArray()//将集合变为对象数组返回
                        public Iterator<E>iterator()//取得Iterator接口对象，用于输出
                                              重点看第一个和最后一个方法
Collection接口中有List接口（允许重复）和Set接口（不允许重复）这两个子接口。还有就是Set接口并没有对Collection接口进行扩充。List接口进行了扩充。
（2）List接口
在实际开发项目中，优先考虑List集合接口 。其中的一些重要方法：
public E get(int index)//根据索引取得保存的数据                  
public E set(int index,E element)//修改数据
List子接口和Collection接口的最大特点在于其有一个get（）方法，可以根据索引取得内容。而List本身还属于一个接口，如果想要取得接口的实例化对象，就必须有子类。
List接口下有三个常用子类：ArrayList,Vector,LinkedList.

(3)ArrayList类
ArrayList是一个针对于List接口的数组操作实现。
示例：
public class Test {

public static void main(String[] args) throws Exception {
List<String> all=new ArrayList<>();//此集合中只允许保存String数据类型
System.out.println(all.size()+","+all.isEmpty());//看集合目前的大小以及是否为空
all.add("hellow");
all.add("hellow");//重复输入
all.add("world");
all.remove("hellow");// 删除数据，需要equals方法
System.out.println(all.size()+","+all.isEmpty());//看集合目前的大小以及是否为空
System.out.println(all.contains("ABC"));//查找数据是否存在，需要使用equals（）
System.out.println(all.contains("world"));//查找数据是否存在，需要使用equals（）
System.out.println(all);

}

}

输出结果0,true
2,false
false
true
[hellow, world]
  所以也证明了List接口允许重复。

（4）观察List的get操作
public class Test {

public static void main(String[] args) throws Exception {
List<String> all=new ArrayList<>();//此集合中只允许保存String数据类型
all.add("hellow");
all.add("hellow");//重复输入
all.add("world");
for(int x=0;x<all.size();x++)
{
System.out.println(all.get(x));
}

}

}
结果如下：
hellow
hellow
world

注意：get方法是List子接口的，如果现在使用的不是List而是Collection，那么对于此时的数据取出你只能将集合变为对象来取出。
示例：用Collection接口进行数据的输出(尽量不用这种操作)
public class Test {

public static void main(String[] args) throws Exception {
Collection<String> all=new ArrayList<>();//此集合中只允许保存String数据类型,注意list是collection的子接口，ArrayList是List子类
all.add("hellow");
all.add("hellow");//重复输入
all.add("world");
//操作一object的形式返回，那么就有可能向下转型，可能造成安全隐患
Object [] result=all.toArray();//变为object对象数组
System.out.println(Arrays.toString(result));
}
}

（5）List与简单java类。
下面的这个例子在实际开发中出现的几率是很低的
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

class Person
{
     private String name;
     private Integer age;//Integer和int最大的区别在于前者能为空
     public Person(String name,Integer age)
     {
       this.name=name;
            this.age=age;
     }
     
     public boolean equals(Object obj)
     {
    if(this==obj)
    {
    return true;
    }
    if(ob
4000
j==null)
    {
     
    return false;
    }
    if(!(obj instanceof Person))
    {
    return false;
    }
    Person per=(Person)obj;//这个地方可以向下转型
    return this.name.equals(per.name)&&this.age.equals(per.age);
     }

     public String toString()
     {
    return "Person [name="+this.name+",age="+this.age+"]";
     
     }

}

public class Test {

public static void main(String[] args) throws Exception {
List<Person> all=new ArrayList<>();
all.add(new Person("张三",12));
all.add(new Person("李四",11));
all.add(new Person("王五",18));
//对于集合中的remove（），contains（）方法必须类中有equals的支持。
/*
*   public boolean contains(Object o) //查找数据是否存在，需要使用equals（）
             public boolean remove(Object o)//删除数据，需要equals方法
*/
all.remove(new Person("张三",12));
       System.out.println(all.contains(new Person("李四",11)));
for(int x=0;x<all.size();x++)
{
System.out.println(all.get(x));

}

}

}
结果如下：
true
Person [name=李四,age=11]
Person [name=王五,age=18]

（6）Vector类与ArrayList类的区别（在用法上，就是将ArrayList换成Vector即可）
                            处理形式                                          数据安全                     输出形式

Vector        同步处理，性能降低                                       线程安全                Iterator,ListIterator,foreach，

ArrayList   异步处理，性能更高                                           非线程安全              Iterator,ListIterator,foreach

  (7)Linkedlsit类与ArrayList区别（在实际开发中，Linkedlsit的用法就是将ArrayList进行替换即可）
  ① ArrayList中放的是数组，如果在实例化此类对象的时候，默认传入了数组的大小（List<Person> all=new ArrayList<>(2);），则里面保存的数组就会开辟一个定长的数组。
    但是如果后面再进行数据保存的时候发现数组的个数不够了，那么会进行数组的动态扩充。如果要使用ArrayList最好的做法就是设置初始化的大小。以分页的程序为例，
    每次只会取出指定行的内容。
 ② Linkedlsit是一个纯粹的链表实现。
总结：ArrayList封装的是一个数组，Linkedlsit封装的是一个链表实现。ArrayList的时间复杂度为1，因为能通过索引直接定位，而Linkedlsit时间复杂度为n。
    开发之中考虑的是ArrayList，如果考虑性能，一定要传入初始化大小。

（8）set接口
   ① Collection接口中有List接口（允许重复）和Set接口（不允许重复）这两个子接口。还有就是Set接口并没有对Collection接口进行扩充。List接口进行了扩充。
     在set接口中不能用get方法。在set接口中有两个常用的子类：HashSet（无序存储），TreeSet（有序存储）。
   ② 示例： 观察HashSet的使用

public class Test {

public static void main(String[] args) throws Exception {
Set<String> all=new HashSet<>();
all.add("hellow");
all.add("hellow");
all.add("world");
System.out.println(all);

}
}
结果是：[hellow, world]。可以看出set接口是不允许重复 的。

示例：TreeSet的使用

public class Test {

public static void main(String[] args) throws Exception {
Set<String> all=new TreeSet<>();
all.add("c");
all.add("c");//重复
all.add("a");
all.add("b");
all.add("d");
System.out.println(all);
}
}

结果是：[a, b, c, d]   可以看出TreeSet的结果是按照升序排列的。set接口是不允许重复的。

（9）TreeSet排序分析
示例：
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
//.java中可以有多个类，但是只能有一个public公共类。
//
class Person 
{
private String name;
private Integer age;
public Person(String name,Integer age)
{
this.name=name;
this.age=age;
}
//一般这个方法使用来把其他类型的数据转为字符串类型的数据的。
public String toString()
{
return "Person name="+this.name+",age="+this.age+"\n";
}

}

public class Test {

public static void main(String[] args) throws Exception {
Set<Person> set=new TreeSet<>();
set.add(new Person("张三",23));
set.add(new Person("张三",23));//重复数据
set.add(new Person("李四",23));//年龄重复
set.add(new Person("王五",29));
System.out.println(set);

}
}
结果是：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 类集概述及相关集合接口.Test.main(Test.java:29)
可以通过TreeSet实现数据的排列处理操作，但是在这个例子中，若进行数据的排序，实际上是针对对象数组进行的排序，若要进行对象数组的排序，那么对象所在的类一定要
实现Comparable接口，重写compareTo（）方法。因为只有通过此方法才能知道大小关系。
改正后：
import java.util.Set;
import java.util.TreeSet;
//.java中可以有多个类，但是只能有一个public公共类。
//
class Person implements Comparable<Person>
{
private String name;
private Integer age;
public Person(String name,Integer age)
{
this.name=name;
this.age=age;
}
//一般这个方法使用来把其他类型的数据转为字符串类型的数据的。
public String toString()
{
return "Person name="+this.name+",age="+this.age+"\n";
}
//这时候要对所有的属性进行比较
public int compareTo(Person o)
{
if(this.age>o.age)
{
return 1;
}else if(this.age<o.age)
{
return -1;
}else
{
return this.name.compareTo(o.name);
}
}
}

public class Test {

public static void main(String[] args) throws Exception {
Set<Person> set=new TreeSet<>();
set.add(new Person("张三",23));
set.add(new Person("张三",23));//重复数据
set.add(new Person("李四",23));//年龄重复
set.add(new Person("王五",29));
System.out.println(set);

}
}
结果：[Person name=张三,age=23
, Person name=李四,age=23
, Person name=王五,age=29
]
用TreeSet进行排序要对所有的属性进行比较，所以太麻烦了。set接口不允许重复。

（10）使用HashSet类时判断重复元素需要依靠Object类中的两个方法：
hash码：public int hashCode();
对象比较：public boolean equals(Object obj)
在java中进行对象比较的操作需要两步：第一步，通过一个对象的唯一编码找到一个对象的信息，当编码匹配之后再调用equals（）方法进行内容的比较。
需要注意的是hashCode和equals方法都可以通过在source中找到generate hashCode（）和equals()自动生成这两个方法。
如果想要标识出对象的唯一性，一定需要hashCode和equals这两个方法。

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
//.java中可以有多个类，但是只能有一个public公共类。
//
class Person implements Comparable<Person>
{
private String name;
private Integer age;
public Person(String name,Integer age)
{
this.name=name;
this.age=age;
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((age == null) ? 0 : age.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age == null) {
if (other.age != null)
return false;
} else if (!age.equals(other.age))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}

  //一般这个方法使用来把其他类型的数据转为字符串类型的数据的。
public String toString()
{
return "Person name="+this.name+",age="+this.age+"\n";
}
//这时候要对所有的属性进行比较
public int compareTo(Person o)
{
if(this.age>o.age)
{
return 1;
}else if(this.age<o.age)
{
return -1;
}else
{
return this.name.compareTo(o.name);
}
}

}

public class Test {

public static void main(String[] args) throws Exception {
Set<Person> set=new HashSet<>();
set.add(new Person("张三",23));
set.add(new Person("张三",23));//重复数据
set.add(new Person("李四",23));//年龄重复
set.add(new Person("王五",29));
System.out.println(set);

}
}
结果：[Person name=张三,age=23
, Person name=李四,age=23
, Person name=王五,age=29
]

总结：在很多时候使用Set集合的核心目的不是让其进行排序，而是让其进行重复元素的过滤，那么使用treeset就没有意义。
但是重复元素需要依靠hashCode和equals两个方法消除，所以如果不是必须的时候，在使用set接口的时候尽量使用系统提供的类实现，例如String，Integer。

可以借鉴的原则：（1）保存自定义类对象时一定用List接口。（2）保存系统类的信息的时候一定用Set接口。