您好,登录后才能下订单哦!
这篇“Java集合方法怎么使用”文章的知识点大部分人都不太理解,所以小编给大家总结了以下内容,内容详细,步骤清晰,具有一定的借鉴价值,希望大家阅读完这篇文章能有所收获,下面我们一起来看看这篇“Java集合方法怎么使用”文章吧。
java集合类存放于java.util包中,是一个用来存放对象的容器
集合只能存放对象
集合存放的是多个对象的引用,对象本身还是存放在堆内存中
集合可以存放不同类型,不限数量的数据类型
Set: 无序,不可重复的集合
List: 有序,可重复的集合
Map:具有映射关系的集合
在JDK5之后,增加了泛型,java集合可以记住容器中对象的数据类型
不能保证元素的排列顺序(位置由该值的hashcode决定)
不可重复(指的是hashcode不相同)
HashSet不是线程安全的
集合元素可以存null
HashSet类实现set接口,set接口继承Collection接口
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是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允许使用重复元素,可以通过索引来访问指定位置的集合元素
List默认按元素的添加顺序设置元素的索引
List集合里添加了一些根据索引来操作集合元素的方法
ArrayList和Vector是List接口的两个典型实现
区别:
Vector是一个古老的集合,通常建议使用ArrayList
ArrayList是线程不安全的,而Vector是线程安全的
即使为保证List集合线程安全,也不推荐使用VectorMap
用于保存具有映射关系的数据,因此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<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存储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是一个操作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<String>(); 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 t) { //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.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); } @Override public void test() { System.out.println("这是实现的ITest接口的test方法"); } } interface ITest { void test(); }
Annotation其实就是代码里的特殊标记,这些标记可以在编译,类加载,运行时被读取,并执行相应的处理。通过使用Annotation,程序员可以在不改变原有逻辑的情况下,在源文件中嵌入一些补充信息
Annotation可以像修饰符一样被使用,可用于修饰包,类,构造器,方法,成员变量,参数,局部变量的声明,这些信息被保存在Annotation的name=value对中
Anotation能被用来为程序元素(类,方法,成员变量等)设置元数据
使用Annotation时要在其前面增加@符号,并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素
三个基本的Annotation:
@Override:限定重写父类方法,该注释只能用于方法
Deprecated:用于表示某个程序元素(类、方法等)已过时
@SuppressWarnings:抑制编译器警告
自定义新的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; @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 ""; }
以上就是关于“Java集合方法怎么使用”这篇文章的内容,相信大家都有了一定的了解,希望小编分享的内容对大家有帮助,若想了解更多相关的知识内容,请关注亿速云行业资讯频道。
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。