JavaSE_集合框架_ArrayList

ArrayListTest

package uncommitted;
import java.util.ArrayList;
import java.util.Iterator;
import org.junit.Test;
import bean.Person;
//用ArrayListTest存储自定义对象Person,name,age
public class ArrayListTest {
   @Test
   public void method3() {
      ArrayList al=new ArrayList();
      al.add(new Person("keke1",21));//Person通过add参数提升为Object
      al.add(new Person("keke2",22));
      al.add(new Person("keke3",23));
      al.add(new Person("keke4",24));
      Iterator it=al.iterator();
      while (it.hasNext()) {//ctrl +1快速修复~自动转换类型
         Person p=(Person) it.next();//存储自定义类型时,一定记得先转型!
         System.out.println(p.getName()+"---"+p.getAge());
//         keke1---21
//         keke2---22
//         keke3---23
//         keke4---24
      }
   }
   @Test
   public void method2() {
      // it.next()只要出现一次,游标就会向下走一行~
      ArrayList al=new ArrayList();
      al.add(new Person("keke1",1));//Person通过add参数提升为Object
      al.add(new Person("keke2",2));
      al.add(new Person("keke3",3));
      al.add(new Person("keke4",4));
      Iterator it=al.iterator();
      while (it.hasNext()) {//ctrl +1自动转换类型
         System.out.println(((Person) it.next()).getName()+"---"+((Person) it.next()).getAge());
         //问题来了!!!结果居然是这样,因为it.next()会自动偏移指针!!!怎么解决?看下一个方法!
         //keke1---2
         //keke3---4
      }
   }
   @Test
   public void method1() {
      ArrayList al=new ArrayList();
      al.add(new Person("keke1",21));
      al.add(new Person("keke2",22));
      al.add(new Person("keke3",23));
      al.add(new Person("keke4",24));
      al.add(5);//自动装箱
      Iterator it=al.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
         /*自定义类型直接打印结果是这样:
         bean.Person@6135d08
         bean.Person@6135d28
         bean.Person@6135d48
         bean.Person@6135d68
         5*/
         /*覆盖Object的toString方法,定义对象独有的打印方法~
         keke1...21
         keke2...22
         keke3...23
         keke4...24
         5*/
      }
   }
}

ArrayListTest2

package uncommitted;
import java.util.ArrayList;
import java.util.Iterator;

import org.junit.Test;

import bean.Person;
public class ArrayListTest2 {
   @Test
   public void method2() {
      //思路:ArrayList的方法contains()在判断是否包含时,
      //仅仅用的是对象自己的equals方法,所以只要覆写对象的equals方法即可!
      // 就可达到去除ArrayList里重复元素(自定义对象类型Person)!
      ArrayList al2=new ArrayList();
      ArrayList temp=new ArrayList();
      al2.add(new Person("宝钗",18));
      al2.add(new Person("宝玉",17));
      al2.add(new Person("黛玉",16));
      al2.add(new Person("宝钗",18));
      System.out.println(al2);
      //[宝钗...18, 宝玉...17, 黛玉...16, 宝钗...18]
      Iterator it=al2.iterator();
      while (it.hasNext()) {
         Object obj=it.next();
         if(!temp.contains(obj)){//如果不包含,就加入到新的容器里面
            temp.add(obj);
         }
      }
      /*上面的contains方法会调用对象自己的equals方法:
       * 而我在Person的equals方法第一句加上了这个:
       * 打印("...Person覆写的equals方法..."+this);
       * this是指当前对象(的toString方法)
       * 而Person的toString也覆写了,打印的不是hashcode,
       * 而是姓名和年龄~
      ...Person覆写的equals方法...宝玉...17
      ...Person覆写的equals方法...黛玉...16
      ...Person覆写的equals方法...黛玉...16
      ...Person覆写的equals方法...宝钗...18
      当ArrayList存第2个(即宝玉)的时候,会与第1个比较一次
      当ArrayList存第3个(即黛玉)的时候,会分别与第1\2个都比较一次
      当ArrayList存第4个(即宝钗)的时候,理论上会分别与第1\2\3个都比较一次
      但是由于和第1个比较的时候就已经发现是重复的了
      (Person的覆写的equals方法规定的同名同姓同年龄则为重复~)
      所以后面的比较就不用进行了~
      */
      System.out.println(temp);
      //[宝钗...18, 宝玉...17, 黛玉...16]
   }
   @Test
   public void method1() {
      // 去除ArrayList里重复元素(字符串)!思路:新建一个ArrayList容器,判断是否包含,增加!
      //contains用的是equals方法,Object的equals方法用的是==
      ArrayList al=new ArrayList();
      ArrayList temp=new ArrayList();
      al.add("abc1");
      al.add("abc2");
      al.add("abc1");
      al.add("abc3");
      System.out.println(al);
      //[abc1, abc2, abc1, abc3]
      Iterator it=al.iterator();
      while (it.hasNext()) {
         Object obj=it.next();
         if(!temp.contains(obj)){//如果不包含,就加入到新的容器里面
            temp.add(obj);
         }
      }
      System.out.println(temp);
       //[abc1, abc2, abc3]
   }
   @Test
   public void method0() {
      //字符串常量~
      Object o1="abc1";
      Object o2="abc1";
      System.out.println(o1);//abc1
      System.out.println(o2);//abc1
      System.out.println(o2.equals(o1));//true
      System.out.println(o2==o1);//true 在内存中是同一地址~(常量池中)
      //字符串对象~
      Object oo1=new String("abc2");
      Object oo2=new String("abc2");
      System.out.println(oo1);//abc2
      System.out.println(oo2);//abc2
      System.out.println(oo2.equals(oo1));//true 字符串对象覆写了equals,比较的是内容
      System.out.println(oo2==oo1);//false  在内存中不是同一地址~(不同的堆内存中)
   }
}

ArrayListDemo3

package uncommitted;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import org.junit.Test;
public class ArrayListDemo11 {
	@Test
   public void show4() {
      List list=new ArrayList();
      //ListIterator 列表迭代器可以从后往前走,老猛!!!
      //add方法默认参数是Object,类型提升了
      list.add("林黛玉");
      list.add("薛宝钗");
      list.add("贾元春");
      list.add("贾探春");
      list.add("史湘云");
      list.add("妙玉");
      list.add("贾迎春");
      list.add("贾惜春");
      list.add("王熙凤");
      list.add("贾巧姐");
      list.add("李纨");
      list.add("秦可卿");      
      ListIterator it=list.listIterator();
      while (it.hasNext()) {
         Object obj=it.next();
         System.out.print(obj+",");
      }
      System.out.println();
      while(it.hasPrevious()){
         Object obj=it.previous();
         System.out.print(obj+",");
      }
      /*林黛玉,薛宝钗,贾元春,贾探春,史湘云,妙玉,贾迎春,贾惜春,王熙凤,贾巧姐,李纨,秦可卿,
      秦可卿,李纨,贾巧姐,王熙凤,贾惜春,贾迎春,妙玉,史湘云,贾探春,贾元春,薛宝钗,林黛玉,*/
      
   }
   @Test
   public void show3() {
      // 用List的listIterator()方法,解决并发修改异常
      //ListIterator可以一边迭代一边增删改
      // 解决异常ConcurrentModificationException
      List list=new ArrayList();
            list.add("abc1");//add方法默认参数是Object,类型提升了
            list.add("abc2");
            list.add("abc3");         
            //List的listIterator()方法,解决并发修改异常
            ListIterator it=list.listIterator();//解决方法:换个迭代器ListIterator
            while (it.hasNext()) {
               Object obj = (Object) it.next();
               if(obj.equals("abc2")){
                  //在abc2后面紧接着就插入了abc9!!!
                  it.add("abc9");//ListIterator一边迭代一边增删改就OK
//                  it.set("abc9");//ListIterator的set方法:void set(E);用E元素替换next返回的最后一个元素
               }
            }      
            System.out.println(list);//[abc1, abc2, abc9, abc3]
            System.out.println(it.hasNext());//false
            System.out.println(it.hasPrevious());
            //true 迭代器ListIterator还可倒着走
   }
   @Test
   public void show2() {
      // 异常ConcurrentModificationException
      List list=new ArrayList();
      list.add("abc1");//add方法默认参数是Object,类型提升了
      list.add("abc2");
      list.add("abc3");
      list.add("abc4");
      //开始使用迭代器操作List元素了,注意(异常)ConcurrentModificationException
      Iterator it=list.iterator();//解决方法:换个迭代器ListIterator
      while (it.hasNext()) {
         Object obj =  it.next();
         if(obj.equals("abc2")){
            list.add("abc9");//同时,List也在操作里面的元素,就会出现并发操作异常
         }
         else
            System.out.println("迭代器取List元素: "+obj);
      }
      //迭代器取List元素: abc1
   }
   @Test
   public void show1() {
      List list=new ArrayList();
      list.add("宝");
      list.add("黛");
      list.add("钗");
      //传统方法:迭代器取List元素
      Iterator it=list.iterator();
      while (it.hasNext()) {
         System.out.println("迭代器取List元素: "+it.next()); 
         
      }
      //List有自己特有的取元素方式:E get(int index)
      //IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
      for (int i = 0; i < list.size(); i++) {
         System.out.println("List特有取元素:E get(int index)"+list.get(i));
      }
      
      /*迭代器取List元素: 宝
      迭代器取List元素:     黛
      迭代器取List元素:     钗
      List特有取元素:E get(int index)宝
      List特有取元素:E get(int index)黛
      List特有取元素:E get(int index)钗*/
   }
}