Collection集合根接口、两个子接口list和set

 

 第一：由数组的缺点来引入集合：

   1.数组只能保存相同的数据类型的数据

   2.数组的长度是不可变的

 

第二：集合的引入

  1.长度可变的数组。集合的容量随着元素的个数自适应变化
  2.可以保存任意类型的元素。

 

第三：Collection根接口和List子接口

1.Collection是根接口（是个接口）

2.List是Collection的子接口（有序的集合也称序列）：允许重复元素的出现。放入集合的数据和取出集合的数据一致，list集合有索引存在（这点跟数组一样有下标）

3.set是Collection的子接口，不能出现重复元素的集合，最多包含一个null（因为两个null就重复了）。也就是说不能包含obj.equals（obj2）==true

 

第四：List接口中实现类

   （一）：Vector实现类:

1.用索引（下标）访问元素，

2.是一个可以自动增长的数组（其实低层就是个数组），

3.数组在定义的时候就要定义好长度，因此长度不可变。而vector如果不定义大小的话就默认开辟一个大小为10的空间（其实就是十个开间的数组，如果不够用的话就每次增长10个），用于保存十个元素。

4，由于底层是个数组，因此对于Vector来说也是用下标获取元素。 在Vector中的get（获取）方法，它调用另一个方法，另一个方法就是数组获取元素的方法。

5.Vector没有重写object的toString方法和equals方法，在 他还是打印和比较的是地址，如果想让他打印和比较的是内容的话，都要重写object的这两个方法 。

6.在多线程情况下是安全的，安全性保证了，就导致速度慢了。
 7.数组的length（长度）方法是返回数组的长度，长度在new的时候已经给定了（也就是开辟的空间，例如开辟10个空间，可我就用了3个，返回的也是10），集合中的size（尺寸）返回的是元素数（例如往里面写三个元素，就返回三个，这也就是长度可变的意思）

8.vector的程序：

public static void main(String[] args) {
  // TODO Auto-generated method stub
  
  //1  创建集合Vector类的对象，该对象封装10个小空间
  Vector vector = new Vector();
  
  boolean flag1 =vector.isEmpty();
  System.out.println("flag1="+flag1);
  //2 容器中保存数据
  vector.add("hello");
  vector.add(100);
  vector.add(123.23);

  int size = vector.size();/**集合的长度是10（默认的），size表示的是元素的个数，因为这里输出的是3

                                      数组中规定length方法返回的数组的长度，而不是数组中元素的个数。**/
  vector.add("hello");vector.add("hello");vector.add("hello");vector.add("hello");

vector.add("hello");vector.add("hello");vector.add("hello");vector.add("hello");
  int size2= vector.size();
  System.out.println("size2="+size2);//这里输出的是12，因为默认长度是10不够用了，又自动增长了10
  
  //3 获取容器中的数据
  for(int x=0;x<vector.size();x++)
  {
   //获取集合中的元素
   Object obj = vector.get(x);
   System.out.println(obj);
  }
  
  //判断集合中有没有指定的元素
  boolean flag = vector.contains("hello wugui");
  System.out.println("flag="+flag);
  //vector.equals(o)  比较集合中对应位置上的元素是否相等
  
  //返回指定元素在集合第一次出现的位置
  int index=vector.indexOf("hello");
  System.out.println("index="+index);
  //删除指定的元素
  vector.remove(3);
  
  for(int x=0;x<vector.size();x++)
  {
   //获取集合中的元素
   Object obj = vector.get(x);
   System.out.println(obj);
  }
  
  //将vector转化为数组
  Object [] arr=vector.toArray();
  
  System.out.println(vector);
 }

 

 

（二）：ArrayList实现类

ArrayList：（此类大致上与Vector一样）:

1.不一样的地方是此类是线程不同步的，不安全（一个一个来）。

2，ArrayList没有重写object的toString方法和equals方法，在contains和remove方法中(这两个方法都需要比较两个元素内容) 他还是打印和比较的是地址，如果想让他打印和比较的是内容的话，都要重写object的这两个方法。

3.程序：

public class Student
{
 
 private String sno;
 private String name;
 private int age;
 public String getSno() {
  return sno;
 }
 public void setSno(String sno) {
  this.sno = sno;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public Student(String sno, String name, int age) {
  super();
  this.sno = sno;
  this.name = name;
  this.age = age;
 }
 public Student() {
  super();
  // TODO Auto-generated constructor stub
 }
 @Override
 public String toString() {
  return "Student [sno=" + sno + ", name=" + name + ", age=" + age + "]";
 }
 
 public boolean equals(Object obj)
 {
  
  if(this==obj)
   return true;
  if(!(obj instanceof Student))
   return false;
  Student stu = (Student)obj;
  
  if(this.sno.equals(stu.sno)&&
    this.name.equals(stu.name)&&
    this.age==stu.age)
  {
   return true;
  }
  
  return false;
  
 }
}

 

 

public static void main(String[] args) {
  
  Student stu1 = new Student("111","小强",26);
  Student stu2 = new Student("112","旺财",24);
  Student stu3 = new Student("113","小白",20);
  Student stu4 = new Student("114","小习",24);
  
  //1 创建集合对象
  ArrayList stuList = new ArrayList();
  //2 保存
  stuList.add(stu1);
  stuList.add(stu2);
  stuList.add(stu3);
  stuList.add(stu4);
  
  //3 遍历输出
  for(int x=0;x<stuList.size();x++)
  {
   
   Object obj = stuList.get(x);
   System.out.println(obj);
  }
  Student stu5 = new Student("114","小习",24);
  boolean flag = stuList.contains(stu5);//注意重写equals方法
  System.out.println("flag="+flag);
  
  Student stu6 = new Student("113","小白",20);
  stuList.remove(stu6);
  
  //3 遍历输出
  for(int x=0;x<stuList.size();x++)
  {
   
   Object obj = stuList.get(x);
   System.out.println(obj);
  }
  
  System.out.println(stuList.toString());
 }
}

 

（三）LinkedList实现类：（他的底层不是数组了，而是链表（单项链表））

1.链表里面的每个小内存空间不一定是连续的（上面两个实现类的每个空间都是连续的）。链表中每个元素都包含两个内容（一个是该空间的内容， 另一个是下一个空间的地址，这就保证了空间不用连续）。2.LinkedList的方法比较多，也就是说他继承了List以外，自己特有的方法比较多。也就是针对开头（first）和结尾（last）的。
3.栈结构：先进后出，体现的就是LinkerList的开头和结尾的应用（这里也体现出他特有的方法）。多出来的方法是addFirst,addLast,getFirst,getLast,removfFirst,removeLast这六个

 

第五：总结：

1.vector:这个内部类里面有一个属性是“obejct类型的数组”，有一个属性是“元素的个数",还有一个是“增长量”。这跟StringBuffer很相似
2.vector是当容量不够用的时候就增加10，每次不够用都增加10个空间，vector可以保存任意类型的元素，因为返回值是object类型的数据
3.集合的放进去拿出来是最常用的操作，放进去就是add方法，拿出来就是对集合的遍历，用到size方法和get方法
4.vector类的contains(包含)这个方法首先调用了vector类的indexof方法（在集合中找指定元素对应的索引），而vector中的indexof方法又调用了vector的equals方法，而vector的equals没有重写object的equals，因此比较的是地址，为了让他比较内容，集合对象重写object类的equals方法
5.remove删除的方法，在删除的时候要先找到才能删除，因此也用到了equals方法

6.set也是Collection的子接口：不能出现重复元素的集合，最多包含一个null（因为两个null就重复了）。也就是说不能包含obj.equals（obj2）==true