ArrayList容器

ArrayList容器类

ArrayList是List接口的实现类。是List在存储特征的具体实现

ArrayList 底层是用数组实现的存储，

特点：存储顺序有序 ，可重复，查询效率高，增删效率低，线程不安全

查询效率高因为可以用索引查询，增删效率低，因为如果操作的不是列表的末尾，增删操作就需要对列表的部分内容进行移位

添加元素

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         String s1 = new String("胖鱼");
         //会加在最后  添加成功返回true，失败返回false
         list.add(s);
         //添加到指定位置   当添加到0号位置，那么之前在0处的s就会后移    没有返回值
         list.add(0,s1);
         //添加的索引不能大于元素的个数，否则会报错
         //list.add(3,s1);
     }
 }

获取元素

通过指定索引位置获取元素

 E get (int index)

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         String s1 = new String("胖鱼");
         list.add(s);
         list.add(0,s1);
         System.out.println(list.get(0));
         System.out.println(list.get(1));
 ​
     }
 }

可以利用get方法来遍历容器

     for(int i=0;i<list.size();i++){
         System.out.println(list.get(i));
     }

替换元素

用元素element取代在指定索引位置上的元素

 E set(int index,E element)

返回值是被替换的元素

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         String s1 = new String("胖鱼");
         list.add(s);
         String val = list.set(0,s1)；
     }
 }

删除元素

根据索引删除元素

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         String s1 = new String("胖鱼");
         list.add(s);
         list.add(0,s1);
         //删除索引为0位置上的元素，删除以后，后面的所有元素都会前移    返回被删除的元素
         System.out.println(list.remove(0));//胖鱼
     }
 }

删除指定的元素

如果给定的元素容器中不存在会返回false

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         String s1 = new String("胖鱼");
         list.add(s);
         list.add(0,s1);
         //删除指定的元素，删除成功返回true，失败返回false
         System.out.println(list.remove(s));//true
         //删除容器中不存在的元素 会返回false，容器中元素不变
         System.out.println(list.remove("fish"));//false
     }
 }

清空容器

void clear();

删除列表中的所有元素

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         String s1 = new String("胖鱼");
         list.add(s);
         list.add(0,s1);
         //清空容器
         list.clear();
         System.out.println(list.size());//0
     }
 }

判断容器是否为空

boolean isEmpty()

容器为空返回true ，反之返回false

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         String s1 = new String("胖鱼");
         list.add(s);
         list.add(0,s1);
         //判断容器是否为空
         System.out.println(list.isEmpty());//false
         //清空容器
         list.clear();
         //清空容器后判断是否为空
         System.out.println(list.isEmpty());//true
     }
 }

判断容器中是否包含指定元素

boolean contains(Object o) 包含元素o返回true ,反之false

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         list.add(s);
         //判断容器中是否包含指定元素
         System.out.println(list.contains("pangyu"));//true
 ​
     }
 }

查找元素的位置

当容器中有重复元素时只能返回这个元素第一次出现的索引或者最后一次出现的索引

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         list.add(s);
         list.add(s);
         list.add("胖鱼");
         list.add(s);
         
         //返回元素在容器中第一次出现的索引
         System.out.println(list.indexOf("pangyu"));//0
         //返回元素在容器中最后一次出现的索引
         System.out.println(list.lastIndexOf("pangyu"));//3
         //如果查找元素不存在，则返回-1
         System.out.println(list.indexOf("fish"));//-1
 ​
     }
 }

将单例集合转换成数组

转换为Object类型的数组

Object [] toArray()

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         list.add(s);
         list.add(s);
         list.add("胖鱼");
         list.add(s);
         //将集合转换为Object类型的数组，这里是不能对转换出来的数组强转为String类型的数组，即使元素本身的类型是String类型   
         Object obj [] = list.toArray();
         for(Object o:obj ){
             System.out.println(o);
          }
          //但是可以逐一进行转换
          for(int i=0;i<obj.length;i++){
             String str = (String)obj[i];
             System.out.println(str);
          }
     }
 }

转换为泛型类型的数组

<T>T [] toArray(T[] a)

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         String s = new String("pangyu");
         list.add(s);
         list.add(s);
         list.add("胖鱼");
         list.add(s);
         //将集合转换为指定类型的数组  类型要与之前的泛型类型相匹配
         String string [] = list.toArray(new String [list.size()] );
         for(Object str:string ){
             System.out.println(str);
         }
     }
 }

容器的并集

这里的并集并不像数学中的并集，数学中的并集不会加入重复的元素。这里更像是将list1容器中的元素全部加入到list容器中

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         list.add("a");
         list.add("b");
         list.add("c");
         List<String> list1 = new ArrayList();
         list1.add("b");
         list1.add("d");
         //list并list1 就是将list1中的元素加入到list中
         list.addAll(list1);
         for(String s :list){
             System.out.println(s);
         }
     }        
 }

容器的交集

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         list.add("a");
         list.add("b");
         list.add("c");
         List<String> list1 = new ArrayList();
         list1.add("b");
         list1.add("d");
         //list交集list1 就是将两个容器中公有元素给到list容器
         boolean flag =list.retainAll(list1);
         System.out.println(flag);
         for(String s :list){
             System.out.println(s);
         }
     }
 }

容器的差集

removeAll

 public class TestArrayList{
     public static void main(String []args){
         //用List作为数据类型   面向接口编程
         List<String> list = new ArrayList();
         list.add("a");
         list.add("b");
         list.add("c");
         List<String> list1 = new ArrayList();
         list1.add("b");
         list1.add("d");
         //就是删除list集合中的list1集合的元素
         list.removeAll(list1);
         for(String s :list){
             System.out.println(s);
         }
     }        
 }
 //a
 //c