List集合以及集合泛型

阳光穿透心脏的1/2处 2022-06-04 22:59 383阅读 0赞

#

List集合

List集合的子实现类的特点:

ArrayList:
底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢
从线程安全问题来看:线程不安全的,不同步,执行效率高，由于ArrayList是List集合的子实现类,它元素可以重复,并且存储和取出一致

  1. import java.util.ArrayList;
  2. import java.util.Iterator;
  4. public class ArrayListDemo {
  6.     public static void main(String[] args) {
  8.         //创建一个ArrayList集合对象
  9.         ArrayList array = new ArrayList() ;
  11.         //添加元素
  12.         array.add("hello") ;
  13.         array.add("hello") ;
  14.         array.add("world") ;
  15.         array.add("world") ;
  16.         array.add("java") ;
  17.         array.add("java") ;
  19.         //遍历元素:
  20.         //1)获取迭代器对象
  21.         Iterator it = array.iterator() ;
  22.         while(it.hasNext()){
  23.             String s = (String)it.next() ;
  24.             System.out.println(s);
  25.         }
  26.     }
  27. }

遍历自定义对象 

  1. import java.util.ArrayList;
  2. import java.util.Iterator;
  4. public class ArrayListDemo2 {
  6.     public static void main(String[] args) {
  8.         //创建ArrayList集合对象
  9.         ArrayList array = new ArrayList() ;
  11.         //创建几个学生对象
  12.         Student s1 = new Student("高圆圆", 27) ;
  13.         Student s2 = new Student("唐嫣", 25) ;
  14.         Student s3 = new Student("邓超", 29) ;
  15.         Student s4 = new Student("黄晓明", 28) ;
  17.         //给集合添加元素
  18.         array.add(s1) ;
  19.         array.add(s2) ;
  20.         array.add(s3) ;
  21.         array.add(s4) ;
  25.         //获取迭代器并遍历
  26.         Iterator it = array.iterator() ;
  27.         while(it.hasNext()){
  28.     //java.lang.ClassCastException: org.westos_01.Student cannot be cast to java.lang.String
  29. //            String s = (String)it.next() ;    类型转换异常
  30.             Student s = (Student) it.next() ;
  31.             System.out.println(s);
  32.         }
  33.     }
  34. }

练习：

需求:ArrayList去除集合中字符串的重复元素
两种方法：
1)创建一个新集合，把没有重复的字符串存进去，并遍历

2)由选择排序的逻辑想到:
拿0索引对应的元素依次和后面索引对应的元素进行比较
同理,1索引对应的元素和后面….. 

  1.    前面的索引对应的元素如果和后面索引对应的元素重复了,从集合移出后面索引的对应的元素
  3. import java.util.ArrayList;
  5. public class ArrayListTest2 {
  7.     public static void main(String[] args) {
  9.         // 创建一个集合,添加重复元素
  10.         ArrayList<String> array = new  ArrayList<String>();
  13.         array.add("hello");
  14.         array.add("hello");
  15.         array.add("Javaweb");
  16.         array.add("world");
  17.         array.add("world");
  18.         array.add("Java");
  19.         array.add("Java");
  20.         array.add("hello");
  21.         array.add("Javaweb");
  22.         array.add("JavaEE");
  23.         array.add("JavaEE");
  25.         ArrayList<String> newArray = new ArrayList<String>();
  27.         for(String s1:array) {
  28.             //判断新集合是否包含旧集合中的元素,没有就添加到新集合
  29.             if(!newArray.contains(s1)) {
  30.                 newArray.add(s1);
  31.             }
  32.         }
  33.         //遍历新集合
  34.         for(String s2 : newArray) {
  35.             System.out.println(s2);
  36.         }
  38.         //System.out.println(array);
  39.         for (int x = 0; x < array.size() - 1; x++) {
  40.             for (int y = x + 1; y < array.size(); y++) {
  41.                 //判断是否重复
  42.                 if (array.get(x).equals(array.get(y))) {
  43.                     array.remove(y);
  44.                     y--;
  45.                 }
  46.             }
  47.         }        
  48.  //增强for遍历
  49.         for(String s3:array) {
  50.             System.out.println(s3);
  51.         }
  52.     }
  53. }

需求：ArrayList去除集合中自定义对象的重复值(对象的成员变量值都相同) 

  1. import java.util.ArrayList;
  3. /**
  4.  * 需求：ArrayList去除集合中自定义对象的重复值(对象的成员变量值都相同)
  5.  * 
  6.  * */
  7. public class ArrayListTest3 {
  9.     public static void main(String[] args) {
  10.         //创建集合
  11.         ArrayList<Student> array = new ArrayList<Student>();
  13.         //创建学生对象
  14.         Student s1 = new Student("李白", 23); 
  15.         Student s2 = new Student("虞姬", 25);
  16.         Student s3 = new Student("李白", 23);
  17.         Student s4 = new Student("王昭君", 25);
  18.         Student s5 = new Student("甄姬", 28);
  19.         Student s6 = new Student("甄姬", 28);
  20.         Student s7 = new Student("王昭君", 25);
  21.         Student s8 = new Student("王昭君", 21);
  22.         //给集合添加元素
  23.         array.add(s1);
  24.         array.add(s2);
  25.         array.add(s3);
  26.         array.add(s4);
  27.         array.add(s5);
  28.         array.add(s6);
  29.         array.add(s7);
  30.         array.add(s8);
  31.         //创建一个新集合
  32.         ArrayList<Student> newArray = new ArrayList<Student>();
  33.         for(Student st1 : array) {
  34.             判断新集合中是否包含这些对象
  35.             if(!newArray.contains(st1)) {
  36.                 newArray.add(st1);
  37.             }
  38.         }
  39.         //遍历新集合
  40.         for(Student st2 :newArray) {
  41.             System.out.println(st2);
  42.         }
  44. /**
  45.  * 发现重复元素依然存在，为什么呢？
  46.  * contains()底层依赖于一个equals()方法,equals()方法是Object类的中的方法,该法默认比较的是对象的地址值是否相同,必须要重写Object中的eqauls()
  47.  *  方法,才能比较内容是否相同;
  48.  *          在自定义对象的类中重写Object中的equasl()方法,才能比较成员变量的值是否相同
  49.  *  看源码:
  50.  *  
  51.  *          ArrayList集合的Contains()源码
  52.  *            public boolean contains(Object o) {
  53.  *              return indexOf(o) >= 0;
  54.  *  }
  55.  *
  56.  *
  57.  *   public int indexOf(Object o) {
  58.  *      if (o == null) {
  59.  *           for (int i = 0; i < size; i++)
  60.  *               if (elementData[i]==null)
  61.  *                   return i;
  62.  *       } else {
  63.  *           for (int i = 0; i < size; i++)
  64.  *               if (o.equals(elementData[i]))
  65.  *                   return i;
  66.  *       }
  67.  *       return -1;
  68.  *   }
  69.  *  重写equasl()方法后，重复元素删除成功
  70.  */
  73.     }
  74. }

练习：集合的嵌套遍历 

  1. public class ArrayListTest {
  3.     public static void main(String[] args) {
  4.         //创建班级集合
  5.         ArrayList<ArrayList<Student>> bigArray = new ArrayList<ArrayList<Student>>();
  6.         //创建第一个学生集合
  7.         ArrayList<Student> firstArray = new ArrayList<Student>();
  8.         //创建学生对象
  9.         Student s1 = new Student("孙尚香", 18);
  10.         Student s2 = new Student("刘备", 23);
  11.         Student s3 = new Student("至尊宝", 27);
  12.         Student s4 = new Student("紫霞仙子", 25);
  14.         firstArray.add(s1);
  15.         firstArray.add(s2);
  16.         firstArray.add(s3);
  17.         firstArray.add(s4);
  18.         //将第一个学生集合添加到班级集合
  19.         bigArray.add(firstArray);
  20.         //创建第二个学生集合
  21.         ArrayList<Student> secondArray = new ArrayList<Student>();
  22.         Student s5 = new Student("叶问水", 18);
  23.         Student s6 = new Student("dreamer_96", 21);
  24.         Student s7 = new Student("二狗子", 27);
  25.         secondArray.add(s5);
  26.         secondArray.add(s6);
  27.         secondArray.add(s7);
  28.         bigArray.add(secondArray);
  29.         //增强for遍历
  30.         for(ArrayList<Student> array:bigArray) {
  31.             for(Student s:array) {
  33.                 System.out.println(s.getName()+"----"+s.getAge());
  34.             }
  35.         }
  37.     }
  38. }

Vector:

底层数据结构是数组的形式,查询快,增删慢
从线程角度看:线程安全的类,同步,执行效率低

特有功能:

public void addElement(E obj)———->相当于:add(Object e)

public Enumeration elements()——->相当于:Iterator iterator() ;

Enumeration接口:向量的组件枚举有两个方法
boolean hasMoreElements():———>相当于:hasNext()
Object nextElement():—————->相当于:next(); 

  1. public class VectorDemo {
  3.     public static void main(String[] args) {
  5.         //创建一个Vector集合对象
  6.         Vector v = new Vector() ;
  8.         //添加元素
  9.         //public void addElement(E obj)
  10.         v.addElement("hello");
  11.         v.addElement("hello");
  12.         v.addElement("world");
  13.         v.addElement("Java");
  15.         //public Enumeration<E> elements()----->相当于:Iterator iterator() ;
  16.         Enumeration en = v.elements() ;
  17.         //遍历元素
  18.         /**
  19.          * boolean hasMoreElements():------>相当于:hasNext()
  20.         Object nextElement():----------->相当于:next();
  21.          */
  22.         while(en.hasMoreElements()){
  23.             //获取元素
  24.             String s = (String)en.nextElement() ;
  25.             System.out.println(s);
  26.         }
  27.     }
  28. }

LinkedList:

底层数据结构是链接列表,特点:查询慢,增删快
从线程角度看:线程不安全的一个类,不同步,执行效率高

如果实现多线程程序,一般要是安全的类:
StringBuffer,Vector,hashtable

synchronized(同步锁对象){
代码;
}

特有功能:
添加功能:
public void addFirst(E e)将指定元素插入此列表的开头。
public void addLast(E e)将指定元素添加到此列表的结尾。
获取功能:
public Object getFirst()返回此列表的第一个元素
public Object getLast()返回此列表的最后一个元素。
删除功能:
public Object removeFirst()移除并返回此列表的第一个元素。
public Object removeLast()移除并返回此列表的最后一个元素。

如果在一般的需求中没有指明使用集合去完成,都默认采用ArrayList
如果需求中要考虑线程安全,那么使用Vector集合!

笔试过程中,一些需求用到集合:就是用ArrayList

  1. public class LinkedListDemo {
  3.     public static void main(String[] args) {
  5.         //创建LinkedList集合
  6.         LinkedList link = new LinkedList() ;
  8.         //添加元素
  9.         link.addFirst("hello") ;
  10.         link.addFirst("world") ;
  11.         link.addFirst("Java") ;
  13.         //public void addFirst(E e)将指定元素插入此列表的开头
  14.         /*link.addFirst("android") ;
  15.         link.addLast("JavaWeb") ;*/
  18.         /**
  19.          * public Object getFirst()返回此列表的第一个元素
  20.             public Object getLast()返回此列表的最后一个元素。
  21.          */
  22.         /*
  23.         Object obj = link.getFirst() ;
  24.         System.out.println(obj);
  25.         Object obj2 = link.getLast() ;
  26.         System.out.println(obj2);*/
  28.         /**
  29.          * public Object removeFirst()移除并返回此列表的第一个元素。
  30.             public Object removeLast()移除并返回此列表的最后一个元素。
  31.          */
  32.         /*System.out.println("removeFirst:"+link.removeFirst());
  33.         System.out.println("removeLast:"+link.removeLast());*/
  35.         //输出集合
  36.         System.out.println("link:"+link);
  37.     }
  38. }

关于数据结构

自定义栈集合类,然后使用LinkedList的一些特有功能模拟栈结构特点

  1. public class LinkedListDemo {
  3.     public static void main(String[] args) {
  6.         //创建LinkedList集合的对象
  7.         LinkedList link = new LinkedList() ;
  8.         //LinkedList集合的特有功能:addFirst(Object e) 
  9.         //栈结构的特点:先进后出
  10.         link.addFirst("hello") ;
  11.         link.addFirst("world") ;
  12.         link.addFirst("java") ;
  14.         Iterator it = link.iterator() ;
  15.         while(it.hasNext()){
  16.             String s = (String)it.next() ;
  17.             System.out.println(s);
  18.         }
  19.     }
  20. }

JDK5.0以后的新特性：

泛型,增强for循环,可变参数,静态导入,自动拆装箱,枚举等等

一.泛型

泛型的引出：

当使用ArrayList存储元素
给ArrayList集合存储了一些元素,String类型的元素,Integer类型的元素
但是通过迭代器遍历元素,由于,系统不知道集合中存储了哪些元素,所有使用String类型接收,就会出现ClassCastException:类转换异常
这样设计不够好!
定义一个数组:字符串数组
String[] str = new String[3] ;
str[0] = “hello” ;
str[1] = “world” ;
当不是字符串类型时：

  1.       str\[2\] = 100 ;//报错误

数组设计这样好处:提前告诉了开发者,这里只能装String类型的元素,Java根据数组特点——>引出:泛型
泛型:把数据类型的明确工作提供提前到了创建对象或者是调用方法的时期明确的一种特殊类型.参数化类型,可以像参数一样进行传递
格式:
<引用类型>:泛型只能放引用类型
泛型好处:
1)将运行时期异常提前到了编译时期
2)解决了黄色警告线问题
3)获取数据的时候,不用强制类型转换了

注意：给类上加入了泛型,在实际测试中,给定了数据类型,获取数据的时候就必须应该类型来接收,否则不匹配

  1. public class GenericDome {
  3.     public static void main(String[] args) {
  4.         //创建ArrayList集合
  5.         ArrayList<Student> array = new ArrayList<Student>();
  6.         Student s1 = new Student("李白",24);
  7.         Student s2 = new Student("杜甫",21);
  8.         Student s3 = new Student("白居易",28);
  9.         Student s4 = new Student("汪伦",25);
  10.         //给集合添加元素
  11.         array.add(s1);
  12.         array.add(s2);
  13.         array.add(s3);
  14.         array.add(s4);
  15.         Iterator<Student> it = array.iterator();
  17.         //迭代器遍历
  18.         while(it.hasNext()) {
  19.             Student s = it.next();
  20.             System.out.println(s.getName()+"------"+s.getAge());
  21.         }
  22.     }
  23. }

泛型定义在方法上： 

  1. public class ObjectTool{
  3.     //将泛型定义在方法上
  4.     public <T> void show(T t){
  5.         System.out.println(t);
  6.     }
  7. }

泛型可以提供程序的安全性!
早期的时候,用Object类型代表任意的类型
向上转型是不会出现问题的,但是向下转型的时候,由于隐藏了类型转换,导致出现错误! 

  1. public class ObjectToolDemo {
  3.     public static void main(String[] args) {
  5.         //创建ObjectTool对象
  6.         ObjectTool ot = new ObjectTool() ;
  7.         //设置数据
  8.         ot.setObj(27) ;//Object obj = new Integer(27):向上转型
  9.         //获取
  10.         Integer i = (Integer) ot.getObj() ;//向下转型
  11.         System.out.println("年龄是:"+i);
  14.         ObjectTool ot2 = new ObjectTool() ;
  15.         //设置
  16.         ot2.setObj("高圆圆") ;//Object obj = new String("高圆圆") ;
  17.         //获取
  18.         String str = (String) ot2.getObj() ;//类型转换了:向下转型:隐藏了类型转换
  19.         System.out.println("姓名是:"+str);
  21.         System.out.println("-------------------------------");
  23.         ObjectTool ot3 = new ObjectTool() ;
  24.         ot3.setObj("邓超") ;
  25.         //java.lang.ClassCastException
  26.         Integer ii = (Integer) ot3.getObj() ;//强制类型转换的接收类型不匹配:程序不安全
  27.         System.out.println("姓名是:"+ii);
  28.     }
  29. }

二.增强for循环：

书写格式:
for(集合或者数组中的数据类型 变量名:集合或者数组的对象名){
输出变量名;
}

增强for循环的弊端:
遍历数组或者集合的时候,数组对象或者集合对象不能为null
如果对象为空,一般加上非空判断

增强for循环的出现就是为了替代迭代器遍历集合的,以后开发中就是用增强for遍历元素 

  1. public class ForDome {
  3.     @SuppressWarnings("unused")
  4.     public static void main(String[] args) {
  5.         //定义一个数组，静态初始化
  6.         int []  arr = {12,13,34,5,22};
  7.         //之前for循环遍历
  8.         for(int x = 0;x < arr.length;x++) {
  9.             System.out.print(arr[x]+" ");//12 13 34 5 22 
  10.         }
  11.         System.out.println();
  12.         //增强for遍历
  13.         for(int i:arr) {
  14.             System.out.print(i+" ");//12 13 34 5 22
  15.         }
  16.         System.out.println();
  17.         //字符串
  18.         String [] strArray = {"一杯敬故乡","一杯敬远方"};
  19.         //增强for遍历
  20.         for(String s:strArray) {
  21.             System.out.print(s+" ");//一杯敬故乡 一杯敬远方 
  22.         }
  23.         System.out.println();
  24.         // 创建ArrayList集合对象,添加并遍历元素
  25.         ArrayList<String> array = new ArrayList<String>();
  26.         // 添加元素
  27.         array.add("hello");
  28.         array.add("world");
  29.         array.add("java");
  30.         //迭代器遍历
  31.         Iterator<String> it = array.iterator();
  32.         while(it.hasNext()) {
  33.             System.out.print(it.next()+" ");// hello world java 
  34.         }
  35.         //增强for遍历
  36.         /*for(String s:array) {
  37.             System.out.print(s+" ");//hello world java 
  39.             if("world".equals(s)) {//java.util.ConcurrentModificationException
  40.                 array.add("Javaweb");
  41.             }
  42.         }*/
  43.         array = null;
  44.         if(array != null) {//非空判断
  45.             for(String s:array) {
  47.                 System.out.print(s+" "); //java.lang.NullPointerException空指针异常 增强for弊端
  48.             }
  49.         }
  51.     }
  52. }

发表评论

表情：
评论列表 （有 0 条评论，383人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java集合泛型

    认识泛型 （1）泛型是JDK1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，使代码可以应用于多种类型。 （2）Java语言引入泛型的好

    小灰灰小灰灰/ 0 赞/ 135 阅读

    相关 二分法搜索List泛型集合

    List集合在项目开发中是最常用的一个集合，在项目中经常需要从集合中查找某一个对象，如果直接用for循环小数据量时没什么性能问题，但是数据量非常大时，用for循环就会显得特别慢

    快来打我*快来打我*/ 0 赞/ 81 阅读