黑马程序员————List集合概述、Arrayist集合、Vector集合、LinkedList集合简述



------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一:ArrayList集合类

（集合中的元素通过get方法取出使用时要强制类型转换，不然不能使用）

 1).是一个具体的类继承于List，底层的数据结构是数组，查找快，增删慢，线程不安全，效率高。
 2).没有特有方法，都是使用的父接口中定义的；
 3).实例：
  A：存储字符串并遍历

public class Demo {
 public static void main(String[] args) {
  //1.定义一个ArrayList
  ArrayList list = new ArrayList();
  //2.填充集合
  list.add("章子怡");
  list.add("高圆圆");
  list.add("刘亦菲");
  list.add("夏添");
  
  //尝试存储重复元素；
  list.add("夏添");
  list.add("刘亦菲");  
  //3.遍历的方式：三种：1.toArray();2.迭代器;3.List接口-->get(int index)
  //1.toArray();
  Object[] objArray = list.toArray();//★★★
  for(int i = 0;i < objArray.length ; i++){
   String s = (String)objArray[i];
   System.out.println(s);
  }
  System.out.println("*******使用迭代器***********");
  //2.迭代器
  Iterator it = list.iterator();//用ListIterator也可以；
  while(it.hasNext()){
   String s = (String)it.next();
   System.out.println(s);
  }
  System.out.println("******使用for循环***********");//取出时的顺序和存入时的顺序是一样的。
  //3.结合：Collection的size()和List的get()方法，使用for循环
  for(int i = 0;i < list.size() ; i++){
  // String s = (String)list.get(i);
  // System.out.println(s);
   Object o = list.get(i);
   System.out.println(o);
  }
  //4.直接打印Arraylist的引用
  System.out.println("************直接打印引用*********");
  System.out.println(list);//打印结果是[章子怡, 高圆圆, 刘亦菲, 夏添, 夏添, 刘亦菲]
 }        //
}

  B：存储自定义对象并遍历

public class Student {
 String name;
 int age;
 public Student(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }
 @Override         //重写student类的tostring（）方法：使其打印其引用的时候，
            //可以返回的是其对象的内容，而不是以前的那种地址值
 public String toString() {
  return "Student [姓名=" + name + ", 年龄=" + age + "]";
 }  
}
public class Demo {
 public static void main(String[] args) {
  //1.定义一个ArrayList
  ArrayList list = new ArrayList();
  
  //2.填充集合
  list.add(new Student("刘亦菲",20));
  list.add(new Student("夏添",22));
  list.add(new Student("高圆圆",24));
  list.add(new Student("章子怡",26));
  
  //尝试存储重复值的对象：
  list.add(new Student("章子怡",26));
  
  //3.使用for遍历
  for(int i = 0; i < list.size() ; i++){
   //为什么要强转？我们要访问Student内的特有成员
  // Student stu = (Student)list.get(i);
  // System.out.println(stu.name + "," + stu.age);
   
   //Student重写toString()后：
   System.out.println(list.get(i));
   //println在使用的时候会默认的调用所要打印的对象的tostring（）方法，
   //如果，此对象所在的类重写了tostring（）方法，就按照重写的打印，否则就按照objct类中的打印。
  }
 }
}

   Vector类：

 1).底层数据结构也是数组，同样查找快，增删慢。但是是线程安全，可效率不高。
 2).是list的子类，具有list和collection的所有方法
 3）特有的方法：
  public void addElement(Object obj):向集合添加一个obj（引用型的元素），添加到集合的末尾；
  public Object elementAt(int index):获取指定索引上的元素，作用等同于：List-->get(int index);
  public Enumeration elements():返回一个枚举
  

   LinkedList类：

 1).底层数据结构是“链表”，查找慢，增删快
 2).线程不安全，效率高
 3).特有方法：
  public void addFirst(E e)及addLast(E e)
  public E getFirst()及getLast()
  public E removeFirst()及public E removeLast()
 4).如果将LinkeList作为链表使用：(先进后出)
   A.使用addFirst()进行添加；
     使用get(int index)进行获取；
   B.使用addFirst()进行添加；
     使用getFirst()获取；
     使用removeFirst()移除第一个元素；
   C.使用add(Object o)进行添加；
      使用getLast()进行获取
     使用removeLast()移除最后的元素；
  如果将LinkedList作为普通的集合使用：（先进先出）
   使用add()添加；
   使用get()获取；
    LinkedList list = new LinkedList();
    list.add("章子怡");
    list.add("张三丰");
    list.add("张学友");
    for(int i = 0;i < list.size(); i++){
    System.out.println(list.get(i));
    }

二、list集合的练习

  1).去除集合中字符串的重复值(字符串的内容相同)
  方式一：
   * 1.跟之前我们做的一个练习：获取20个不重复的随机数思路差不多；
   * 2.开辟一个新集合。
   * 3.遍历原集合，并获取每一个元素；
   * 4.在新集合中判断，是否存在该元素，
   *   如果不存在，则存储到新集合中；
   *   如果存在，就取下一个元素；继续遍历
   */

public class Demo
{
 public static void main(String[] args){
  ArrayList list=new ArrayList ();
  list.add("刘亦菲");
  list.add("王菲");
  list.add("章子怡");

  list.add("章子怡");
  list.add("刘亦菲");
  ArrayList<String> list2=new ArrayList<>();
  //遍历第一个容器
  for (int i=0;i<list.size() ;i++ )
  {
   //做一个标记，用来识别是否要添加进入list2
   boolean lean=true;
   for (int j=0;j<list2.size() ;j++ )
   {
    if((list2.get(j)).equals(list.get(i))){
     lean=false;//如果找到相同的就改写标记
     break;
    }
   }
   if(lean){
   list2.add(list.get(i));
   }
  }
  System.out.println(list);
  System.out.println(list2);
 }
}
/**
ArrayList list2 = new ArrayList();
  
  //3.遍历原集合
  for(int i = 0 ;i < list.size() ; i++){
   String s = (String) list.get(i);
   //判断新集合中是否有这个元素：
   if(!list2.contains(s)){
    //添加到新集合中
    list2.add(s);
   }
此方法判断更简单：contians方法
*/

   方法二：
   1.在原集合上进行遍历，并判断；
   2.将每个元素，依次和它后面的每个元素进行比较；
   3.如果发现重复，将把后面的元素删除掉；
    注意：删掉元素后，集合的大小将立即发生改变；将循环变量减1;
   

 ArrayList list=new ArrayList();
    for(int i=0;i<list.size();i++){
    for(int j=i;j<list.size();j++){
     if(list.get(j).equals(list.get(i))){
      list.remove(j);
      j--;
     }    
    }
    }
    System.out.println(list);

   
   
  2).去除ArrayList中的重复的内容_自定义对象
   之前去除重复的字符串，使用了两种方式:
   1.建立一个新集合
   2.在原集合的基础上进行遍历并修改原集合
   方法一：

public class Demo {
 public static void main(String[] args) {
  ArrayList<Student> list=new ArrayList<>();
  list.add(new Student("高圆圆",32));
  list.add(new Student("赵翠翠",28));
  list.add(new Student("赵梅香",27));
  list.add(new Student("张慧慧",25));
  list.add(new Student("赵梅香",27));
  //定义一个新的集合
  ArrayList<Student> list2=new ArrayList<>();
  //list2.add(list.get(0));
  for(int i=0;i<list.size();i++){
   //遍历新的集合，查看是否有相同的元素
   
   boolean lean=true;
   for(int j=0;j<list2.size();j++){
    if((list.get(i).equals(list2.get(j)))){//重写集合中元素（对象）中的equals方法
     lean=false;
     break;
    }    
   }   
   if(lean){
    list2.add(list.get(i));
   }
  }
   
   System.out.println("打印原集合"+list);//重写集合中元素（对象）中的tostring()方法
   System.out.println("打印新集合"+list2);  
 }




}
public class Student {
 String name;
 int age;
 public Student(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }
 @Override
 public boolean equals(Object obj){  //重写student类的equals方法，以便使用类使用的时候直接比较引用的内容，而不是其地址值
  Student stu=(Student)obj;
  if (this.name.equals(stu.name)&&this.age==stu.age)
   return true;
  return false;
  
 }
 @Override
 public String toString(){    //重写 tostring（）方法，直接打印其内容而不是地址值。
  return "name="+this.name+",age="+this.age; 
 }

  

  方法二：

public class Demo {
 public static void main(String[] args) {
  ArrayList<Student> list=new ArrayList<>();
  list.add(new Student("高圆圆",32));
  list.add(new Student("赵翠翠",28));
  list.add(new Student("赵梅香",27));
  list.add(new Student("张慧慧",25));
  
  list.add(new Student("赵梅香",27));
  System.out.println("移除之前打印"+list);
  //创建循环
  for(int i=0;i<list.size();i++){
   //分别和之后的每一个元素比较，使用循环遍历
   for (int j = i+1; j < list.size(); j++) {
    //取出元素比较，如果相同就移除后者，不过由于集合的数组特性，之后的元素要前移，
    //为了可以遍历全部元素，必须将移除处的索引再比较一次，j--
    if(list.get(i).equals(list.get(j))){//此处需要在对象所在类中重写equals方法，以便于比较内容值。
     list.remove(j);
     j--;
    }    
   }
  }
  System.out.println("移除之后的效果"+list);//注意此处已经重写了list中元素对象的tostring方法不然就是打印地址值  
 }
}

  3）使用LinkedList模拟栈结构
   A.要求：自定义一个集合类；
   B.这个集合类要模拟栈的结构：先进后出
   C.自定义的集合类，内部可以使用LinkedList实现
public class Demo {
 public static void main(String[] args) {
  //1.先实例化一个自定义的集合，它就相当于LinkedList
  MyLinkedList list = new MyLinkedList();
  
  //2.填充元素：
  list.addFirst("aaa");
  list.addFirst("bbb");
  list.addFirst("ccc");
  
  //3.提取元素,看是不是会先进后出
 

 Object o = list.getFirst();
  System.out.println(o);
  o = list.getFirst();
  System.out.println(o);
  o = list.getFirst();
  System.out.println(o);
 }
}

public class MyLinkedList {
 private LinkedList linkedList = new LinkedList();
 
 //实际上就是模拟linkedlist的三中方法：添加，获取，长度
 //不过由于获取是按照栈结构，要先进后出。
 //模拟LinkedList的行为：addFirst();
 public void addFirst(Object obj){
  this.linkedList.addFirst(obj);
 }
  
 //模拟LinkedList的getFirst();
 //java.util.LinkedList的getFirst()方法只获取第一个元素，但不做其他操作，每次获取的都是相同的元素；
 //这里我们进行一下改进，每次获取完第一个元素后，将第一个元素删除掉；
 public Object getFirst(){
  //先取出第一个元素；
  Object obj = this.linkedList.getFirst();
  //删除掉第一个元素
  this.linkedList.removeFirst();
  //将刚刚获取的第一个元素返回
  return obj;
 }
 
 //要遍历这个集合，还得提供一个size()方法
 public int size(){
  return this.linkedList.size();
 }
}