运维开发网
广告位招商联系QQ:123077622
 
广告位招商联系QQ:123077622

带你入门Java的集合

运维开发网 https://www.qedev.com 2021-07-07 10:01 出处:网络 作者: 独爱郑爽
目录java集合集合分类---Set、List、Map三种大体系SetHashSetHashCode()方法TreeSet自然排序ListList与ArrayListArrayList和VectorMapTreeMap操作集合的工具类:Collections查找、替换同步控制泛型为什么要有泛型枚举
目录
  • java集合
    • 集合分类---Set、List、Map三种大体系
    • Set
      • HashSet
      • HashCode()方法
      • TreeSet
      • 自然排序
    • List
      • List与ArrayList
      • ArrayList和Vector
    • Map
      • TreeMap
      • 操作集合的工具类:Collections
        • 查找、替换
          • 同步控制
            • 泛型
              • 为什么要有泛型
            • 枚举类
            • Annotation(注解)概述
              • 基本的Annotation
                • 自定义Annotation
                • 总结

                  java集合

                  java集合类存放于java.util包中,是一个用来存放对象的容器

                  • 集合只能存放对象
                  • 集合存放的是多个对象的引用,对象本身还是存放在堆内存中
                  • 集合可以存放不同类型,不限数量的数据类型

                  集合分类---Set、List、Map三种大体系

                  • Set: 无序,不可重复的集合
                  • List: 有序,可重复的集合
                  • Map:具有映射关系的集合

                  在JDK5之后,增加了泛型,java集合可以记住容器中对象的数据类型

                  Set

                  HashSet

                  • 不能保证元素的排列顺序(位置由该值的hashcode决定)
                  • 不可重复(指的是hashcode不相同)
                  • HashSet不是线程安全的
                  • 集合元素可以存null

                  HashSet类实现set接口,set接口继承Collection接口

                  HashCode()方法

                  HashSet集合判断两个元素相等的标准:两个对象通过equals()方法比较相等,并且两个对象的hashCode()方法返回值也相等。

                  如果两个对象通过equals()方法返回true,这两个对象的hashCode值也应该相同。

                  如果要set集合存相同类型的对象需使用泛型

                  package com.aggregate.demo;
                  import com.sun.corba.se.spi.ior.IORTemplateList;
                  import java.util.HashSet;
                  import java.util.Iterator;
                  public class set {
                      public static void main(String[] args) {
                          HashSet<Object> set = new HashSet<>();
                          set.add(1);
                          set.add("a");//增加元素
                          System.out.println(set);
                          set.remove(1);//移除元素
                          System.out.println(set);
                          System.out.println(set.contains("a"));//判断集合中是否存在该元素
                          set.clear();//清空集合
                          System.out.println(set);
                          //遍历集合
                          set.add("a");
                          set.add("b");
                          set.add("c");
                          set.add("d");
                          //1.使用迭代器遍历集合
                          Iterator<Object> iterator = set.iterator();
                          while (iterator.hasNext()) {
                              System.out.print(iterator.next() + "\t");
                          }
                          System.out.println("===============");
                          //2.for each迭代集合
                          for (Object i : set) {
                              System.out.print(i + "\t");
                          }
                          System.out.println("===============");
                          System.out.println(set.size());//获取元素的个数
                          set.add(null);
                          System.out.println(set);
                          //使用泛型存相同类型的元素
                          HashSet<String> set1 = new HashSet<>();
                          set1.add("123");
                  //      set1.add(2);
                      }
                  }

                  TreeSet

                  TreeSet是SortedSet接口的实现类,TreeSet可以确保集合元素处于排序状态。

                  TreeSet支持两种排序方法:自然排序和定制排序。默认情况下,TreeSet采用自然排序

                  自然排序

                  排序:TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系,然后将集合元素按升序排列

                  自定义类如何排序?

                  import java.util.Comparator;
                  import java.util.Iterator;
                  import java.util.TreeSet;
                  public class Tree {
                      public static void main(String[] args) {
                          TreeSet<Integer> treeSet = new TreeSet<>();
                          //TreeSet自然排序
                          treeSet.add(5)编程客栈;
                          treeSet.add(1);
                          treeSet.add(3);
                          treeSet.add(2);
                          treeSet.add(4);
                          System.out.println(treeSet);
                          treeSet.remove(3);
                          System.out.println(treeSet);
                          System.out.println(treeSet.contains(0));
                          treeSet.clear();
                          System.out.println(treeSet);
                          Iterator<Integer> iterator = treeSet.iterator();
                          while (iterator.hasNext()) {
                              System.out.println(iterator.next());
                          }
                          System.out.println("=============");
                          for (Integer i : treeSet) {
                              System.out.println(i);
                          }
                          Person P1 = new Person(23, "张三");
                          Person P2 = new Person(25, "李四");
                          Person P3 = new Person(12, "王五");
                          Person P4 = new Person(5, "Lucy");
                          Person P5 = new Person(99, "hhhh");
                          TreeSet<Person> people = new TreeSet<>(new Person());
                          people.add(P1);
                          people.add(P2);
                          people.add(P3);
                          people.add(P4);
                          people.add(P5);
                          for (Person i : people) {
                              System.out.println(i.name + "  " + i.age);
                          }
                      }
                  }
                  //把person对象存到TreeSet中并且按照年龄排序
                  class Person implements Comparator<Person> {
                      int age;
                      String name;
                      public Person() {
                      }
                      public Person(int age, String name) {
                          this.age = age;
                          this.name = name;
                      }
                      @Override
                      public int compare(Person o1, Person o2) {//年龄正序排序
                          if (o1.age > o2.age) {
                              return 1;
                          } else if (o1.age < o2.age) {
                              return -1;
                          } else {
                              return 0;
                          }
                      }
                  }

                  List

                  List与ArrayList

                  List代表一个元素有序、且可重复的集合,集合中的每个元素都有其对应的顺序索引

                  List允许使用重复元素,可以通过索引来访问指定位置的集合元素

                  List默认按元素的添加顺序设置元素的索引

                  List集合里添加了一些根据索引来操作集合元素的方法

                  ArrayList和Vector

                  ArrayList和Vector是List接口的两个典型实现

                  区别:

                  • Vector是一个古老的集合,通常建议使用ArrayList
                  • ArrayList是线程不安全的,而Vector是线程安全的
                  • 即使为保证List集合线程安全,也不推荐使用VectorMap

                  Map

                  用于保存具有映射关系的数据,因此Map集合里保存着两组值,一组值用于保存Map里key,另外一组用于保存Map里的Value

                  Map中的key和value都可以是任何引用类型的数据

                  Map中的key不允许重复,即同一个Map对象的任何两个Key通过equals方法比较返回false

                  key和value之间存在单向一对一关系,即通过指定的ke编程客栈y总能找到唯一的,确定的Value

                  HashMap & Hashtable

                  HashMap和Hashtable是Map接口的两个典型实现类

                  区别:

                  • Hashtable是一个古老的Map实现类,不建议使用
                  • Hashtable是线程安全的Map实现,但HashMap是线程不安全的
                  • Hashtable不允许使用null作为key和value,而HashMap可以

                  与HashSet集合不能保证元素的顺序一样,Hashtable、HashMap也不能保证其中key-value对的顺序

                  Hashtable、HashMap判断两个key的标准是:key通过equals方法返回true,hashCode值也相等

                  Hashta5ble相等的标准是:两个Value通过equalHashMap判断两个Value方法返回true

                  import java.util.HashMap;
                  import java.util.Map;
                  import java.util.Set;
                  public class MapDemo {
                      public static void main(String[] args) {
                          Map<String, Integer> map = new HashMap<String, Integer>();
                          map.put("b", 1);//添加数据
                          map.put("c", 2);
                          map.put("d", 3);
                          System.out.println(map);
                          System.out.println(map.get("d"));//根据key取值
                          map.remove("c");
                          System.out.println(map);//根据key键值对
                          System.out.println(map.size());//map集合的长度
                          System.out.println(map.containsKey("a"));//判断当前的map集合是否包含指定的key
                          System.out.println(map.containsValue(10));//判断当前的map集合是否包含指定的value
                  //        map.clear();//清空集合
                          Set<String> keys = map.keySet();//可以获取map集合的key的集合
                          map.values();//获取集合的所有value值
                          //遍历map集合,通过map.keySet();
                          for (String key : keys) {
                              System.out.println("key:" + key + ", value:" + map.get(key));
                          }
                          //通过map.entrySet();遍历集合
                          Set<Map.Entry<String, Integer>> entries = map.entrySet();
                          for (Map.Entry<String, Integer> entry : entries) {
                              System.out.println("key:" + entry.getKey() + ", value:" + entry.getValue());
                          }
                      }
                  }

                  TreeMap

                  TreeMap存储key-value对时,需要根据key对key-value对进行排序。TreeMap可以保证所有的key-value对处于有序状态

                  TreeMap的key排序

                  • 自然排序:TreeMap的所有的key必须实现Comparable接口,而且所有的key应该是同一个类的对象,否则将会抛出ClassCastException
                  • 定制排序(了解):创建TreeMap时,传入一个Comparator对象,该对象负责对TreeMap中的所有key排序。此时不需要Map的key实现Comparator接口
                  import java.util.Map;
                  import java.util.TreeMap;
                  public class TreeMapDemo {
                      public static void main(String[] args) {
                          //TreeMap的自然排序是字典
                          Map<Integer, String> treemap = new TreeMap<Integer, String>();
                          treemap.put(4, "a");
                          treemap.put(3, "b");
                          treemap.put(2, "c");
                          treemap.put(1, "d");
                          System.out.println(treemap);
                          Map<String, String> map = new TreeMap<String, String>();
                          map.put("a", "a");
                          map.put("c", "a");
                          map.put("d", "a");
                          map.put("b", "a");
                          map.put("ab", "a");
                          System.out.println(map);
                  
                      }
                  }

                  操作集合的工具类:Collections

                  Collections是一个操作Set 、List和Map等集合的工具类

                  Collections中提供了大量方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变,对集合对象实现同步控制等方法

                  排序操作:

                  • reverse(List):反转List中元素的顺序
                  • shuffle(List):对List集合元素进行随机排序
                  • sort(List):根据元素的自然顺序对指定List集合元素升序排序
                  • sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序s
                  • wap(List,int,int):将指定list集合中的i处元素和j处元素进行交换

                  查找、替换

                  Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素

                  Object max(Collection,Comparator):根据Comparator指定的顺序,返回给定集合中的最大元素

                  Object min(Collection)

                  Object min(Collection,Comparator)

                  int frequency(Collection,Object):返回指定集合中指定元素的出现次数

                  boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List对象的所有旧值

                  import java.util.ArrayList;
                  import java.util.Collections;
                  import java.util.Comparator;
                  import java.util.List;
                  public class Test {
                      public static void main(String[] args) {
                          List<String> list = new ArrayList<>();
                          list.add("a");
                          list.add("c");
                          list.add("d");
                          list.add("f");
                          list.add("b");
                          System.out.println(list);
                          Collections.reverse(list);//反转List中元素的顺序
                          System.out.println(list);
                          Collections.shuffle(list);//对list集合元素进行顺序排序
                          System.out.println(list);
                          Collections.sort(list);//list集合字典升序排序
                          System.out.println(list);
                          Student s1 = new Student(14, "张三");
                          Student s2 = new Student(12, "李四");
                          Student s3 = new Student(13, "王五");
                          Student s4 = new Student(11, "小刘");
                          List<Student> students = new ArrayList<Student>();
                          students.add(s1);
                          students.add(s2);
                          students.add(s3);
                          students.add(s4);
                          for (Student student : students) {
                              System.out.println(student.name + "," + student.age);
                          }
                          Collections.sort(students, new Student());
                          System.out.println("==========");
                          for (Student student : students) {
                              System.out.println(student.name + "," + student.age);
                          }
                          Collections.swap(list, 1, 3);//将指定list集合中的i处元素和j处元素进行交换
                          System.out.println(list);
                          System.out.println(Collections.max(list));
                          System.out.println(Collections.min(list));
                          Student max = Collections.max(students, new Student());
                          Student min = Collections.min(students, new Student());
                          System.out.println(max.name + ", " + max.age);
                          System.out.println(min.name + ", " + min.age);
                          System.out.println(Collections.frequency(list, "a"));
                          System.out.println(Collections.replaceAll(list, "a", "aa"));
                          System.out.println(list);
                      }
                  }
                  class Student implements Comparator<Student> {
                      int age;
                      String name;
                      public Student() {
                      }
                      public Student(int age, String name) {
                          this.age = age;
                          this.name = name;
                      }
                      @Override
                      //根据年龄升序排序对象
                      public int compare(Student o1, Student o2) {
                          if (o1.age > o2.age) {
                              return 1;
                          } else if (o1.age < o2.age) {
                              return -1;
                          } else {
                              return 0;
                          }
                      }
                  }

                  同步控制

                  Collections类中提供了多个synchronizedxxx()方法该方法可使指定集合包装成线程同步的集合;从而解决多线程并访问集合时的线程安全问题。

                  泛型

                  为什么要有泛型

                  集合中使用泛型时只有指定类型才可以添加到集合中,类型安全

                  java中的泛型,只在编译阶段有效。

                  泛型类

                  • 对象实例化时不指定泛型,默认为:object
                  • 泛型不同的引用不能相互赋值
                  public class Test2 {
                      public static void main(String[] args) {
                          A<String> a = new A<String>();
                          a.setKey("rexx");
                          String s = a.getKey();
                          System.out.println(s);
                      }
                  }
                  class A<T> {
                      private T key;
                      public T getKey() {
                          return key;
                      }
                      public void setKey(T key) {
                          this.key = key;
                      }
                  }

                  泛型接口

                  定义一个泛型接口

                  未传入泛型实参时,与泛型类的定义相同,在声明类的时候,需将泛型的声明也一起加到类中

                  泛型方法

                  package com.aggregate.demo;
                  public class Test3 {
                      public static void main(String[] args) {
                          B1<Object> b1 = new B1<Object>();
                          B1<String> b2 = new B1<Strhttp://www.cppcns.coming>();
                          B2 b3 = new B2();
                          Cc cc = new Cc();
                          cc.test("xxx");
                          //泛型方法,在调用之前没有固定的数据类型
                          //在调用时,传入的参数是什么类型,就会把泛型改成什么类型
                          //也就是说,泛型方法会在调用时确定泛型具体的数据类型
                          Integer integer = cc.test1(2);
                          Boolean aBoolean = cc.test1(true);
                      }
                  }
                  //定义泛型接口
                  interface IB<T> {
                      T test(T t);
                  }
                  //未传入泛型实参时,与泛型类的定义相同,在声明类的时候,需将泛型的声明也一起加到类中
                  class B1<T> implements IB<T> {
                      @Override
                      public T test(T t) {
                          return null;
                      }
                  }
                  //传入实际参数
                  //如果实现接口时指定接口的泛型的具体数据类型
                  //这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型
                  class B2 implements IB<String> {
                      @Override
                      public String test(String s) {
                          return null;
                      }
                  }
                  //泛型方法
                  class Cc {
                      public void test() {
                      }
                      //无返回值的泛型方法
                      public <T> void test(T s) {
                          T t = s;
                      }
                      public String test1(String s) {
                          return s;
                      }
                      //有返回值的泛型方法
                      public <T> T test1(T s) {
                          return s;
                      }
                      public void test2(String... strs) {
                          for (String s : strs) {
                              System.out.println(s);
                          }
                      }
                      //形参为可变参数的泛型方法
                      public <T> void test2(T... strs) {
                          for (T str : strs) {
                              System.out.println(str);
                          }
                      }
                  
                  }
                  //带泛型的类可以在类里面定义泛型的变量
                  class Dd<E> {
                      private E e;
                      //静态的泛型方法
                      public static <T> void test3(T http://www.cppcns.comt) {
                          //System.out.println(this.e);
                          //在静态方法中,不能使用类定义泛型,如果要使用泛型,只能使用静态方法自己定义的泛型
                          System.out.println(t);
                      }
                      //在类上定义的泛型,可以在普通的方法中使用
                      public <T> void test(T s) {
                          System.out.println(this.e);
                          T t = s;
                      }
                  }

                  通配符

                  1.有限制的通配符

                  • (无穷小,Person]只允许泛型为Person及Person子类的引用调用
                  • [Person,无穷大)只允许泛型为Person及Person父类的引用调用
                  • 只允许泛型为实现Comparable接口的实现类的引用调用

                  枚举类

                  在某些情况下,一个类的对象是有限而且固定的。例如季节类,只能有4个对象。

                  手动实现枚举类:

                  • private修饰构造器
                  • 属性使用private final修饰
                  • 把该类的所有实例都使用public static final来修饰

                  实现接口的枚举类

                  • 和普通Java类一样枚举类可以实现一个或多个接口
                  • 若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式,则可以让每个枚举值分别来实现该方法
                  public class Test5 {
                      public static void main(String[] args) {
                          //Season.SPRING,这段执行就是获取一个Season的对象
                          Season spring = Season.SPRING;
                          spring.showInfo();
                          Season summer = Season.SUMMER;
                          summer.showInfo();
                          Season spring1 = Season.SPRING;
                          //每次执行Season.SPRING获得是相同的对象,枚举类中的每个枚举都是单例模式的
                          System.out.printhttp://www.cppcns.comln(spring.equals(spring1));
                          spring1.test();
                      }
                  }
                  enum Season implements ITest {
                      SPRING("春", "春暖花开"),//此处相当于调用有参的私有构造
                      SUMMER("夏", "夏日炎炎"),
                      AUTUMN("秋", "秋高气爽"),
                      WINTER("冬", "寒风凛冽");
                  
                      private final String name;
                      private final String desc;
                      Season(String name, String desc) {
                          this.name = name;
                          this.desc = desc;
                      }
                      public void showInfo() {
                          System.out.println(this.name + ":" + this.desc);
                      }
                      @Override
                      public void test() {
                          System.out.println("这是实现的ITest接口的test方法");
                      }
                  }
                  
                  interface ITest {
                      void test();
                  }

                  Annotation(注解)概述

                  Annotation其实就是代码里的特殊标记,这些标记可以在编译,类加载,运行时被读取,并执行相应的处理。通过使用Annotation,程序员可以在不改变原有逻辑的情况下,在源文件中嵌入一些补充信息

                  Annotation可以像修饰符一样被使用,可用于修饰包,类,构造器,方法,成员变量,参数,局部变量的声明,这些信息被保存在Annotation的name=value对中

                  Anotation能被用来为程序元素(类,方法,成员变量等)设置元数据

                  基本的Annotation

                  • [email protected][email protected]持的程序元素
                  • 三个基本的Annotation:
                    • @Override:限定重写父类方法,该注释只能用于方法
                    • Deprecated:用于表示某个程序元素(类、方法等)已过时
                    • @SuppressWarnings:抑制编译器警告

                  自定义Annotation

                  [email protected]

                  [email protected][email protected]名字和类型

                  可以在定义Annotation的成员变量时为其指定初始值,指定成员变量的初始值可使用default关键字

                  没有成员定义的Annotation称为标记;包含成员变量的Annotation称为元数据的Annotation

                  import java.lang.annotation.*;
                  import java.util.ArrayList;
                  import java.util.List;
                  public class Test6 {
                      public static void main(String[] args) {
                          new TestB().test01();
                          @SuppressWarnings({})
                          List list = new ArrayList();
                      }
                  }
                  class TestA {
                      public void test() {
                      }
                  }
                  class TestB extends TestA {
                      @TestAnn(id = 100, desc = "姓名")
                      String name;
                      @Override
                      public void test() {
                          super.test();
                      }
                      @Deprecated
                      public void test01() {
                      }
                  }
                  @Target(ElementType.FIELD)//这个注解类是给其他类的属性做注解
                  @Retention(RetentionPolicy.RUNTIME)//定义注解的声明周期
                  @Documented
                  @interface TestAnn {
                      public int id() default 0;
                      public String desc() default "";
                  }

                  总结

                  本篇文章就到这里了,希望能给您带来帮助,也希望您能够多多关注我们的更多内容!

                  扫码领视频副本.gif

                  0

                  精彩评论

                  暂无评论...
                  验证码 换一张
                  取 消