黑马程序员--Java基础之集合类

JAVA 学习第14天，今天学习的内容是集合类，之所以会存在集合类，是因为集合操作的是对象，且它的特点是长度不固定。

import java.util.*;

/*
集合类：概念
由来：方便对""“对象”""的操作，对对象存储，集合是存储对象最常用的一种方式
特点：用于存储对象，集合长度是可变的，集合可以存储不同类型的对象
与数组的区别：

    List (ArrayList,LinkedLlist,Vector)
Collection
    Set  (HashSet,TreeSet)

Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引
  |--ArrayList: 底层的数据结构使用的是数组结构。特点：查询速度快，但是增删慢，线程不同步
  |--LinkList：底层使用的是链表数据结构，特点：增删速度快，查询稍慢
  |--Vector：底层是数组数据结构。线程同步。被ArrayList替代了

|--Set: 元素是无序的，元素不可以重复
|--Set: 元素是无序的(存入和取出的顺序不一定一致)，元素不可以重复
|--HashSet:底层数据结构式哈希表

   HashSet是如何保证元素的唯一性的呢？
   是通过元素的两个方法，hashSet和equals来完成。
   如果元素的hashCode值相同，不会判断equals是否为true
   如果元素的hashSet值不同，才会调用equals

   注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals的方法

|--TreeSet:

为什么会出现这么多的容器呢？
因为每一个容器对数据的存储方式都有不同，这个存储方法称之为：数据结构

1，add方法的参数类型是Object，以便于接收任意类型对象
2，集合中存储的都是对象的引用（地址）

什么是迭代器 //生活实例：电玩城中大罐子玩具的取出，夹子
其实就是集合的去除元素的方式。是一个接口

就把取出方式定义在集合的内部。这样取出方式就可以直接访问集合内部的元素

那么取出方式就被定义成了内部类

而每一个容器的数据结构不同
所以取出的动作细节也不一样，但是都有共性内容
判断和取出，那么可以将这些共性抽取

那么这些内部类都符合一个规则，该规则就是Iterator。
如何获取集合的取出对象呢？
通过一个对外提供的方法：
iterator();

class CollectionDemo
{
public static void main(String[] args)
{
method_get();

}

public static void method_get() //方法用于获取集合容器中的元素
{
ArrayList al = new ArrayList();

  al.add("java1"); //1,往al容器中添加元素，add(Object obj);
  al.add("java2");
  al.add("java3");
  al.add("java4");

  //al.iterator(); 获取迭代器，用于去除集合中的元素
  //Iterator it = al.iterator();
  //it.next();   用于获取迭代器中的元素
  //it.hasNext();    用于判断迭代器中是否还有元素
  /*
  while (it.hasNext())
  {

   sop(it.next());
  }*/

  for (Iterator it=al.iterator();it.hasNext() ; )
  {
   sop(it.next());
  }
}

public static void method_2()
{
ArrayList al1 = new ArrayList();

  al1.add("java1");
  al1.add("java2");
  al1.add("java3");
  al1.add("java4");

  ArrayList al2 = new ArrayList();

  al2.add("java1");
  al2.add("java2");
  al2.add("java5");
  al2.add("java6");

//al1.retainAll(al2); //取交集，al1剩下java1，java2
al1.removeAll(al2); //将相同的去除，剩下自己不同的

  sop("al1"+al1);
  sop("al2"+al2);

}

public static void baseMethod()
{
//创建一个集合容器，使用Collection接口的子类，ArrayList
ArrayList al = new ArrayList();

  al.add("java1"); //1,往al容器中添加元素，add(Object obj);
  al.add("java2");
  al.add("java3");
  al.add("java4");

//打印原来集合
sop("原集合"+al);

  //3,删除元素
  //al.remove("java2");
  //al.clear(); //清空集合

  //4,判断元素
  sop("java3是否存在："+al.contains("java3"));
  sop("al是否为空："+al.isEmpty());

  //2,获取al容器的元素，长度
  sop(al.size());
  //打印改变后的集合
  sop("改变后集合"+al);

}
public static void sop(Object obj)
{
  System.out.println(obj);
}
}

import java.util.*;
/*
Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引
  |--ArrayList: 底层的数据结构使用的是数组结构。特点：查询速度快，但是增删慢，线程不同步
  |--LinkList：底层使用的是链表数据结构，特点：增删速度快，查询稍慢
  |--Vector：底层是数组数据结构。线程同步。被ArrayList替代了

|--Set: 元素是无序的，元素不可以重复
|--Set: 元素是无序的(存入和取出的顺序不一定一致)，元素不可以重复
   |--HashSet:底层数据结构式哈希表
   HashSet是如何保证元素的唯一性的呢？
   是通过元素的两个方法，hashSet和equals来完成。
   如果元素的hashCode值相同，才会判断equals是否为true
   如果元素的hashSet值不同，才会调用equals

   注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals的方法

|--TreeSet:

List集合特有的方法；
凡是可以操作角标的方法都是该体系特有的方法
增
add(index,element); 在指定位子增加元素
addAll(index,Collect);
删
remove(index); 删除指定位子元素
改
set(index,element);  将指定位置的元素修改为新的element
查
get(index);  查找指定位置的元素
subList(form,to); 获取集合中的部分内容，包含头，不包含脚
listIterator();  迭代器

重点：List集合特有的迭代器，ListIterator是Iterator的子接口，

在迭代时，不可以通过集合对象的方法操作集合中的元素
因为会发生异常

所以，在迭代器时，只能用迭代的方式操作元素，可是Iterator方法是有限的
只能对元素进行判断，取出，删除的操作
如果想要其他的操作如添加，修改等，就需要使用其子接口 ListIterator

该接口只能通过List集合的ListIterator方法获取

class ListDemo
{
public static void main(String[] args)
{
listiteratorDemo();
}

public static void listiteratorDemo()
{
  ArrayList al = new ArrayList();
  //容器添加元素
  al.add("java01");
  al.add("java02");
  al.add("java03");
  sop("原有元素："+al);

ListIterator li = al.listIterator();

  while (li.hasNext())   //正向遍历hasNext()
  {
   Object obj = li.next();
   if (obj.equals("java02"))
    //li.add("java005");
    li.set("java007");

}
sop("改变后的元素"+al);

  while (li.hasPrevious())   // 反向遍历li.hasPrevious()
  {
   sop("hasPrevious"+(li.hasPrevious()));
  }

  /*
  Iterator it = al.iterator();
  while(it.hasNext()) //正向遍历，下一个位置有元素
  {
   Object obj =it.next();
   if(obj.equals("java02"))
    al.add("java008"); //出现异常
   sop(obj);
  }
  sop(al);
  */
}

public static void method_list()
{
  ArrayList al = new ArrayList();
  //容器添加元素
  al.add("java01");
  al.add("java02");
  al.add("java03");
  al.add("java04");

  sop("原有元素："+al);
  //在指定位置上添加元素
  al.add(1,"java009");
  // 删除指定位子元素
  al.remove(2);
  //将指定位置的元素修改为新的element
  //al.set(2,"java007");
  //查找指定位置的元素
  //sop("al[1]="+al.get(1));

  //sop("改变后的元素"+al);
  //迭代器
  Iterator it = al.iterator();
  while (it.hasNext())
  {
   sop(it.next());
  }
  //通过indexOf获取对象元素的位置
  sop("java003的位置是："+al.indexOf("java03"));
  //获取集合中的部分内容，包含头，不包含脚
  List sub = al.subList(1,3);
  sop("1到3的部分元素sub="+sub);

}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

/*
需求：使用LinkedList方法，自定义数据结构，队列，堆栈

堆栈：先进后出如同一个杯子
队列：先进先出 First In First Out FIFO 如同一个水管

*/
import java.util.*;

class QueueDemo
{
private LinkedList link;
QueueDemo()
{
link= new LinkedList();
}

public void mySet(Object obj)
{

  link.addFirst(obj);
}
public Object myGet()
{
  return link.removeLast();
}
public boolean isNull()
{
  return link.isEmpty();
}
}

class LinkedListTest
{
public static void main(String[] args)
{
  QueueDemo qu = new QueueDemo();
  qu.mySet("spide01");
  qu.mySet("spide02");
  qu.mySet("spide03");
  qu.mySet("spide04");
  qu.mySet("spide05");

  while (!qu.isNull())
  {
   sop(qu.myGet());
  }

}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

import java.util.*;
/*
需求：去除ArrayList数组数据中重复的元素

思路：1，首先有这样一个包含重复元素的ArrayList数据集合
   2，有一个新的ArrayList数据类型的newAl数据集合
   3，遍历原来的数据集合中数据元素，如果新的数据集合中没有这个元素，
   就放到新的数据集合中，如果有的话，就丢掉这个数据元素

class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}

public static void main(String[] args)
{
  ArrayList al = new ArrayList();
  al.add("spider01");
  al.add("spider02");
  al.add("spider01");
  al.add("spider02");
  al.add("spider01");
  al.add("spider03");
  al.add("spider01");

sop("原来的数组集合数据"+al);

al=getSingleArrayList(al);

sop("改变后的数组集合数据"+al);

}

public static ArrayList getSingleArrayList(ArrayList al)
{
ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器，用于接收al集合

  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   Object obj = it.next();

   if (!newAl.contains(obj)) //判断新集合中是否包含该元素
    newAl.add(obj);
  }

  return newAl;
}
}

/*
需求：使用LinkedList方法，自定义数据结构，队列，堆栈

堆栈：先进后出如同一个杯子
队列：先进先出 First In First Out FIFO 如同一个水管

*/
import java.util.*;

class QueueDemo
{
private LinkedList link;
QueueDemo()
{
link= new LinkedList();
}

public void mySet(Object obj)
{

  link.addFirst(obj);
}
public Object myGet()
{
  return link.removeLast();
}
public boolean isNull()
{
  return link.isEmpty();
}
}

}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

import java.util.*;
/*
需求：去除ArrayList数组数据中重复的元素

class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}

sop("原来的数组集合数据"+al);

al=getSingleArrayList(al);

sop("改变后的数组集合数据"+al);

}

public static ArrayList getSingleArrayList(ArrayList al)
{
ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器，用于接收al集合

  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   Object obj = it.next();

   if (!newAl.contains(obj)) //判断新集合中是否包含该元素
    newAl.add(obj);
  }

  return newAl;
}
}

import java.util.*;
/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素

比如：存人对象，同姓名同年龄，视为同一个人，为重复元素

思路：
1，对人描述，将数据封装进人对象
2，定义容器，将人存入
3，取出

*/
/*
class Person
{
private String name;
private int age;
Person(String name,int age)
{
  this.name = name;
  this.age = age;
}
public int getAge()
{
  return age;
}
public String getName()
{
  return name;
}
}

class ArrayListTest2
{
public static void sop(Object obj)
{
System.out.println(obj);
}

public static void main(String[] args)
{
ArrayList al = new ArrayList();

  al.add(new Person("zzh001",23));//object obj = new Person(" ", )
  al.add(new Person("zzh002",24));
  al.add(new Person("zzh003",25));
  al.add(new Person("zzh004",26));
  al.add(new Person("zzh001",23));
  al.add(new Person("zzh002",24));

  al = getSingleElement(al);

  Iterator it = al.iterator();
  while (it.hasNext())
  {
   Object obj = it.next();
   Person p = (Person)obj;
   sop(p.getName()+"....."+p.getAge());
   /*
   //程序运行到这一步，打印结果为
   zzh001",23
   zzh002",24
   zzh003",25
   zzh004",26
   zzh001",23
   zzh002",24
   比较后的没有将重复的zzh001和zzh002去除

   是因为contains(obj)比较的是对象的地址，调用时object的equals的方法
   比较的是地址而每个对象都是new出来的，地址都不一样，所以不会取出，
   所以没有比较对象中的姓名和年龄是否相同，
   getSingleElement（）函数总(!newAl.contains(obj))返回的都是真(就是不包含，会添加到新的集合中)

   解决方法是Person类中重写equals方法，让他判断对象的姓名和年龄

}

public static ArrayList getSingleElement(ArrayList al)
{
ArrayList newAl = new ArrayList();

  Iterator it = al.iterator(); //定义迭代器，用于接收al集合

  while (it.hasNext()) //判断al元素中是否有下一个元素
  {
   Object obj = it.next();

   if (!newAl.contains(obj)) //判断新集合中是否包含该元素
    newAl.add(obj);
  }

  return newAl;
}
}

class Person
{
private String name;
private int age;
Person(String name,int age)
{
  this.name = name;
  this.age = age;
}
public boolean equals(Object obj) //复写object的equals的方法，判断年龄、姓名是否相同
{
  if (!(obj instanceof Person))
   return false;

Person p = (Person)obj;
return this.name.equals(p.name) && this.age==p.age;

}
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
}

class ArrayListTest2
{
public static void sop(Object obj)
{
System.out.println(obj);
}

public static void main(String[] args)
{
ArrayList al = new ArrayList();

  al = getSingleElement(al);

  Iterator it = al.iterator();
  while (it.hasNext())
  {
   Object obj = it.next();

   //it.next()迭代器取得的对象元素是Object类型，而要Person方法需要转换成Person类型
   Person p = (Person)obj;
   sop(p.getName()+"....."+p.getAge());

  }
}