锐客网

  1. 首页 > it技术 > >

带你入门Java的集合

目录

  • 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 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 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 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 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 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 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 {int age; String name; public Person() {}public Person(int age, String name) {this.age = age; this.name = name; }@Overridepublic 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之间存在单向一对一关系，即通过指定的key总能找到唯一的，确定的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 map = new HashMap(); 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集合是否包含指定的keySystem.out.println(map.containsValue(10)); //判断当前的map集合是否包含指定的value//map.clear(); //清空集合Set 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 entries = map.entrySet(); for (Map.Entry 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 treemap = new TreeMap(); treemap.put(4, "a"); treemap.put(3, "b"); treemap.put(2, "c"); treemap.put(1, "d"); System.out.println(treemap); Map map = new TreeMap(); 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 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 students = new ArrayList(); 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 {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 a = new A(); a.setKey("rexx"); String s = a.getKey(); System.out.println(s); }}class A {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 b1 = new B1(); B1 b2 = new B1(); B2 b3 = new B2(); Cc cc = new Cc(); cc.test("xxx"); //泛型方法，在调用之前没有固定的数据类型//在调用时，传入的参数是什么类型，就会把泛型改成什么类型//也就是说，泛型方法会在调用时确定泛型具体的数据类型Integer integer = cc.test1(2); Boolean aBoolean = cc.test1(true); }}//定义泛型接口interface IB {T test(T t); }//未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中class B1 implements IB {@Overridepublic T test(T t) {return null; }}//传入实际参数//如果实现接口时指定接口的泛型的具体数据类型//这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型class B2 implements IB {@Overridepublic String test(String s) {return null; }}//泛型方法class Cc {public void test() {}//无返回值的泛型方法public void test(T s) {T t = s; }public String test1(String s) {return s; }//有返回值的泛型方法public T test1(T s) {return s; }public void test2(String... strs) {for (String s : strs) {System.out.println(s); }}//形参为可变参数的泛型方法public void test2(T... strs) {for (T str : strs) {System.out.println(str); }}}//带泛型的类可以在类里面定义泛型的变量class Dd {private E e; //静态的泛型方法public static void test3(T t) {//System.out.println(this.e); //在静态方法中，不能使用类定义泛型，如果要使用泛型，只能使用静态方法自己定义的泛型System.out.println(t); }//在类上定义的泛型，可以在普通的方法中使用public 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.println(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); }@Overridepublic void test() {System.out.println("这是实现的ITest接口的test方法"); }}interface ITest {void test(); }


                  Annotation(注解)概述 Annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过使用Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息
                  Annotation可以像修饰符一样被使用，可用于修饰包，类，构造器，方法，成员变量，参数，局部变量的声明，这些信息被保存在Annotation的name=value对中
                  Anotation能被用来为程序元素（类，方法，成员变量等）设置元数据

                  基本的Annotation
                  • 使用Annotation时要在其前面增加@符号，并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素
                  • 三个基本的Annotation：
                    • @Override:限定重写父类方法，该注释只能用于方法
                    • Deprecated：用于表示某个程序元素（类、方法等）已过时
                    • @SuppressWarnings:抑制编译器警告

                  自定义Annotation
                  自定义新的Annotation类型使用@interface关键字
                  Annotation的成员变量在Annotation定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型
                  可以在定义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; @Overridepublic void test() {super.test(); }@Deprecatedpublic void test01() {}}@Target(ElementType.FIELD)//这个注解类是给其他类的属性做注解@Retention(RetentionPolicy.RUNTIME)//定义注解的声明周期@Documented@interface TestAnn {public int id() default 0; public String desc() default ""; }


                  总结 【带你入门Java的集合】本篇文章就到这里了，希望能给您带来帮助，也希望您能够多多关注脚本之家的更多内容！

                    推荐阅读


                    上一篇：Android开发简单计算器实现代码

                    下一篇：BufferedWriter如何使用write方法实现换行