Day08

集合

1. 是对象的容器，实现了对对象的常用操作，实现数组的功能

2. 和数组的区别

   • 数组长度固定，集合长度不固定

   • 数组可以存储基本类型和引用类型，集合只能存储引用类型

Collection体系集合

1. Collection集合的使用

    package cn.ljy.Collection;
    ​
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    ​
    public class Demo01 {
        public static void main(String[] args) {
            Collection collection=new ArrayList();//因为接口不能实例化，所以选着了list下的ArrayList()类
            collection.add("桃子");//collection添加一个桃子
            collection.add("苹果");
            collection.add("香蕉");
            collection.add("西瓜");
            System.out.println("元素个数"+collection.size());//打印列表中元素的个数
            System.out.println(collection);//打印collection
            /*删除collection中单个元素
            //collection.remove("西瓜");
            //collection.clear();//清空
            System.out.println(collection);*/
            //遍历元素
            /*使用foreach来实现遍历*/
            for(Object a:collection){
                System.out.println(a);
            }
            /*
            使用迭代器来实现迭代
             */
            System.out.println("=================================================");
            Iterator iterator = collection.iterator();//对collection进行迭代的迭代器，返回值是一个接口Iterator
            /*
            hasNext():有没有下一个元素
            next():获取下一个元素
            remove():删除当前元素
            */
            while(iterator.hasNext()){
    ​
                String next=(String)iterator.next();
    ​
                System.out.println(next);
                //iterator.remove();
                //collection.remove(next);在使用迭代器的时候不能使用collection.remove方法
    ​
            }
            System.out.println("元素个数"+collection.size());//打印列表中元素的个数
            //判断
            System.out.println(collection.contains("香蕉"));//判断是否含有香蕉
            System.out.println(collection.isEmpty());//判断是否为空
        }
    }
    ​

 

2. List接口的使用

   • add():添加

   • remove():删除

   • iterator():迭代器

   • get():根据角标来获取元素

   • listIterator():list专有的迭代器

   • list.nextIndex():返回next后元素的索引

   • list.previousindex():返回前一个元素的索引

   • contain():判断是否有xx元素

   • isEmpty():判断是否为空

   • indexof():获取该元素的位置

   • sublist():返回子列表，可以指定位置含头不含尾

      package cn.ljy.Collection;
      ​
      import java.util.*;
      ​
      public class Demo04 {
          public static void main(String[] args) {
              List list=new ArrayList<>();
              //添加元素
              list.add("apple");
              list.add("xiaomi");
              list.add("huawei");
              //删除元素
              list.remove(new String("apple"));
              //遍历列表（有下标可以使用for循环）
              System.out.println("============================使用for循环的遍历=============================");
              for (int i=0;i< list.size();i++){
                  System.out.println(list.get(i));
              }
              System.out.println("============================使用foreach循环的遍历=============================");
              for (Object l1:list) {
                  System.out.println(l1);
              }
              System.out.println("============================使用迭代器的遍历=============================");
              Iterator it=list.iterator();
              while (it.hasNext()){
                  System.out.println(it.next());
              }
              System.out.println("============================使用list迭代器的从前往后遍历=============================");
              ListIterator ite= list.listIterator();
              while(ite.hasNext()){
                  System.out.println(ite.nextIndex()+":"+ite.next());
      ​
              }
              System.out.println("============================使用list迭代器的从后往前遍历===============================");
              while(ite.hasPrevious()){
                  System.out.println(ite.previousIndex()+":"+ite.previous());
              }
              //判断是否有xx元素，判断是否为空
              boolean b1=list.contains("xiaomi");
              System.out.println(b1);
              System.out.println(list.isEmpty());
              //获取该元素的索引
              System.out.println(list.indexOf("huawei"));
              //返回子列表
              System.out.println(list.subList(0, 1));
          }
      }
      ​

      

• List常用的实现类

  • ArrayList：

    源码分析：DEFAULT_CAPACITY=10;默认容量（如果没有像集合中添加任何元素时，容量为0，添加一个任意元素后，容量变为10，每次扩容都是容量变为原来的1.5倍）

    elementData：存放元素的数组

    size：实际元素个数

  • Vector：（遍历需要使用枚举器，其他与ArrayList相同）

     Enumeration en=vector.elements();
     while(en.hasMoreElements()){
         String o=(String)en.nextElement();
         System.out.println(o);
     }

  • LinkedList:ArrayList使用的方法也可以在Linked List中使用（也就是双项链表）

  3. Set类型的接口

  • 方法和list一样

  • 无序，没有下标（在添加的时候没有顺序）

  • 不能重复

     package cn.ljy.Collection;
     ​
     import java.util.HashSet;
     import java.util.Iterator;
     import java.util.Set;
     ​
     public class Demo06 {
         public static void main(String[] args) {
             Set<String> s=new HashSet<>() ;
             s.add("l");
             s.add("lk");
             s.add("lj");
             s.add("ljy");
             System.out.println("元素个数为："+s.size());
             System.out.println(s.toString());//无序
             //遍历
             Iterator it= s.iterator();
             while(it.hasNext()){
                 System.out.println(it.next());
             }
     ​
         }
     }
     ​

  Set实现类

  • HashSet基于HashCode运算元素存放，当放入元素的哈希码相同时调用equals进行确认，为true拒绝存入

  • TreeSet：红黑树存储，当ComparableTo方法返回值为0判断元素为重复

    • Comparator：进制比较器的使用

       package cn.ljy.Collection;
       ​
       import com.sun.source.util.Trees;
       ​
       import java.util.Comparator;
       import java.util.TreeSet;
       ​
       public class Demo08 {
           public static void main(String[] args) {
               TreeSet<Student> t=new TreeSet<>(new Comparator<Student>() {
                   @Override
                   public int compare(Student o1, Student o2) {
                       int n1=o1.getAge()-o2.getAge();
                       int n2=o1.getName().compareTo(o2.getName());
                       return n1==0?n2:n1;
                   }
               });
               Student s1=new Student("ljy",10);
               Student s2=new Student("ljy",10);
               t.add(s1);
               t.add(s2);
               System.out.println(t.size());
       ​
           }
       }
       ​

       

 

泛型

1. 泛型类

2. 泛型 接口

3. 泛型方法

4. 泛型集合

 

Map集合

1. Map接口的使用

   • 存储键值对

   • 键不能重复，值可以重复

   • 无序

 package cn.ljy.Collection;
 ​
 import javax.swing.text.html.parser.Entity;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 ​
 public class Demo09 {
     public static void main(String[] args) {
         Map<String,String> m= new HashMap<String,String>();
         m.put("1","l");//添加put();
         m.put("2","j");
         m.put("3","y");
         System.out.println("元素个数为："+m.size());
         m.remove("2");//移除();
         System.out.println("元素个数为："+m.size());
         //遍历
         System.out.println("+======================================+");
         Set<String> keys=m.keySet();//Keyset()：是把key的值提取到m这个空间中
         for (String key:keys){
             System.out.println(key);
         }
         System.out.println("+======================================+");
         Set<Map.Entry<String,String>> map=m.entrySet();//entrySet()：方法是把整个键值对提取出来放入空间
         for (Map.Entry map1:map){
             System.out.println(map1);
 ​
         }
         //判断
         System.out.println(m.containsKey("1"));//判断是否有这个key
         System.out.println(m.containsValue("l"));//判断是否有这个值
     }
 }
 ​

2. Map的实现类

   • HashMap集合的使用

     • 存储结构：哈希表（数组+链表+红黑树）

     • 使用Key的hashcode和equals来判断是否重复

   • TreeMap：和TreeSet相识