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集合存相同类型的对象需使用泛型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
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)方法来比较元素之间的大小关系,然后将集合元素按升序排列
自定义类如何排序?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
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之间存在单向一对一关系,即通过指定的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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
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接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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对象的所有旧值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
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
- 泛型不同的引用不能相互赋值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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;
}
}
|
泛型接口
定义一个泛型接口
未传入泛型实参时,与泛型类的定义相同,在声明类的时候,需将泛型的声明也一起加到类中
泛型方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
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类一样枚举类可以实现一个或多个接口
- 若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式,则可以让每个枚举值分别来实现该方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
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可以像修饰符一样被使用,可用于修饰包,类,构造器,方法,成员变量,参数,局部变量的声明,这些信息被保存在Annotation的name=value对中
Anotation能被用来为程序元素(类,方法,成员变量等)设置元数据
基本的Annotation
- 使用Annotation时要在其前面增加@符号,并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素
-
三个基本的Annotation:
- @Override:限定重写父类方法,该注释只能用于方法
- Deprecated:用于表示某个程序元素(类、方法等)已过时
- @SuppressWarnings:抑制编译器警告
自定义Annotation
自定义新的Annotation类型使用@interface关键字
Annotation的成员变量在Annotation定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型
可以在定义Annotation的成员变量时为其指定初始值,指定成员变量的初始值可使用default关键字
没有成员定义的Annotation称为标记;包含成员变量的Annotation称为元数据的Annotation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
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 "" ;
}
|
总结
本篇文章就到这里了,希望能给您带来帮助,也希望您能够多多关注服务器之家的更多内容!
原文链接:https://www.cnblogs.com/lvcong/p/14966329.html