JavaSE之集合框架

前言

本文包含了Java集合框架中的Java类集的简介,List集合接口,Set集合接口,集合输出,Map集合,栈与队列,Properties属性操作,Collections工具类以及Stream数据流

Java类集简介

什么是Java类集?

类集实际上就是动态对象数组,在我们平时的实际开发中会发现数组的使用率并不高,归结原因便是数组本身的一个重大缺点–>数组的长度是固定的.每当数组元素已满时,我们想要继续存放元素,就会产生很多问题,带来操作上的不便,由于此问题.在JDK1.2开始,Java为我们提供了动态的对象数组实现框架–Java类集框架.Java集合类框架实际上就是Java针对数据结构的一种实现.

Collection接口

在数据结构中最为基础的就是线性表了是,而Collection的底层实现其实就是线性表.Collection接口的操作形式与之前编写链表的操作形式类似,但每一次进行数据操作的时候只能够对单个对象进行处理

Collection是单个集合保存的最大父接口

Collection接口的定义如下:

1
public interface Collection<E> extends Iterable<E>

我们可以看到Collection接口是继承自Iterable接口的.需要说明的是我们很少会直接使用Collection接口,Collection接口只是一个存储数据的标准,并不能区分存储类型.例如:要存放的数据需要区分重复与不重复.我们往往会考虑的接口是Collection接口的子接口:List(允许数据重复),Set(不许允数据重复)
(上述接口之间的关系如下图所示)

Collection接口有俩个重要的方法 add(),iterator();且子接口中也都有这两个方法
其他方法可参考api,由于我们不直接使用Collection接口,所以不列举他的其他方法~
以后提到Java类集我们应该想到Collection类,清楚他的父类以及子类.知道类集其实就是Java提供的数据结构的api接口,他封装了一些好的常用的数据接口以便提高开发人员的编程效率

List接口

在List接口中除了继承自Collection接口中的方法外还有两个十分重要的扩展方法:get()和set()方法

由于List本身还是个接口,并不能直接实例化对象,所以他就必须要有自己的子类,在List接口下有三个常用的子类:ArrayList,Vector,LinkedList

(其实这三个类都不是直接实现List接口的实现类,而是一个抽象类的实现类,而这个抽象类又继承自List接口,他们之间关系如下图)

ArrayList(优先考虑)

ArrayList是一个针对List接口的数组实现(实际就是线性表中的顺序表,但他可以采用动态数组的形式实现).下面为ArrayList的基本使用

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
public static void code1(){

//List的常用方法
List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("!!!");
//List允许有重复数据
list.add("hello");
//覆写了Collection的add()方法
list.add(1, "hh");
list.set(2, "myworld"); //将指定位置的元素替换
list.remove(1); //删除指定下标处的元素
list.remove("hello"); //删除第一次出现的元素
list.removeAll(list); //删除指定列表
System.out.println(list.isEmpty()); //判断列表是否为空
System.out.println(list.contains("hello")); //判断列表是否包含某元素
System.out.println(list.containsAll(list)); //判断列表是否包含某个列表
System.out.println(list.indexOf("hh")); //返回目标元素第一次出现的下标
System.out.println(list.lastIndexOf("hello")); //返回目标元素最后一次出现的下标


//三种遍历列表的方式
//常规for语句+get()方法
//get()方法:返回此列表中指定下标元素
for (int i = 0; i < list.size(); i++) {
System.out.println(((ArrayList<String>) list).get(i));
}

//foreach语句+get()方法
for (String i : list) {
System.out.println(i);
}

//常用
//迭代器 iterator(): 以正确的顺序返回该列表中的元素的迭代器
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}

使用Collection接口来进行操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//通过Collection进行输出处理
public static void code2() {

Collection<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("!!!");
//注意此时试用add这种方法需要向下转型,因为Collection中的add没有此类的构造方法
((ArrayList<String>) list).add(1, "my");

Object[] arr1 = list.toArray();
//此处存在向下转型
for (Object i : arr1) {
System.out.println(i);
}

String[] arr2 = new String[list.size()];
//toArray():以正确的顺序返回列表中元素的一个数组
list.toArray(arr2);
for (String j : arr2) {
System.out.println(j);
}
}

当然,我们也可以使用Arrays类本身没的toString()方法来打印列表

1
2
3
4
5
6
7
8
9
10
public static void code3(){
Collection list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");

Object[] arr = list.toArray();
//Arrays.toString() 返回指定数组的字符串表示形式
System.out.println(Arrays.toString(arr));
}

集合与Java类

大多数情况下在我们的列表中存放的数据成员都是Java类的对象~那么如何使用集合来存放Java类?在存放Java类的情况下需要注意些什么?

首先我们先自己写一个Persion类

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
class Persion{

private String name ;
private Integer age;

public Persion(String name,Integer age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

@Override
public String toString() {
return "Persion{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}

@Override
public boolean equals(Object obj) {
if(this == obj){
return true;
}

if(obj==null || this.getClass() != obj.getClass()){
return false;
}

Persion persion = (Persion) obj;
if(!this.name.equals(persion.name)){
return false;
}
return this.age.equals(persion.age);
}

@Override
public int hashCode() {
int result = this.name.hashCode();
result = result*31+age.hashCode();
return result;
}
}

仔细观察这个类,会发现在这个类中我们重写了三个方法:toString(),equals(),hashCode(),为什么要重写这三个方法呢?

toString()的重写原因

在Java中所有的类都隐式的继承自Object类,如果我们的类中没有toString()方法,那么在输出一个对象的时候会默认调用Object类中的toString()方法,而默认的toString()方法是十分不友好的,他总是返回 类名+@+hashCode,这样以来打印出来的内容有时候让我们很摸不着头脑,所以在我们自己定义的类中需要重写toString()方法,已达到我们期望的目的

equals()的重写原因

与toString()类似,在Object类中也有equals方法,如果在我们的类中不重写equals方法在调用的时候就会默认使用Object中的equals方法,而默认的equals方法他比较的是两个对象的引用,即对象的地址(详细参考源码).这样就造成我们看似两个一样的对象实际比较的结果却是不相同的.所以我们需要按照自己的比较方式来重写equals()方法

hashCode()的重写原因

在Java中,如果我们重写了equals()方法,就要重写hashCode()方法以用来维护hashCode()的常规协定!hashCode的常规协定规定如果两个对象相等,那么这两个对象一定具有相等的hashCode.所以当我们重写了equals方法,那么对应生成对象hashCode的方法也应该和此时的equals方法对照统一,否则就会产生对象比较相同,但是hashCode却不同的违规现象,由此产生了理解上的不一致

集合类中存放Java类方法演示(ArrayList实现)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void code4(){
List<Persion> list = new ArrayList<>();
list.add(new Persion("Jack",22));
list.add(new Persion("Alice",18));
list.add(new Persion("Alex",19));
list.add(new Persion("Tom",20));


System.out.println("当前人员:");
Iterator<Persion> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
list.remove(new Persion("Jack",22)); //如果没有重写equals()方法,则此处不能成功删除
System.out.println(list.contains(new Persion("Alice",18))); //没有重写equals()方法,也不能正常使用
//为什么会造成如上的原因? 因为remove()和contains()方法都用到了equals().我们需要重新覆写equals()
//当我们重新覆写了equals()和hashCode后发现结果和我们预期的达到一致

System.out.println("删除后人员:");
Iterator<Persion> iterator2 = list.iterator();
while(iterator2.hasNext()){
System.out.println(iterator2.next());
}
}

Vector

Vector的底层实现也是可增容的数组,那么他与ArrayList有什么区别呢?
首先,Vector在JDK1.0早于ArrayList时被提出,ArrayList的提出是在JDK1.2;
其次,ArrayList是异步处理,他的方法之间是线程不同步的,是线程不安全的,但是他的性能更高;Vector是同步处理,性能较低,但他是线程安全的,他的方法之间是线程同步的
Vector实现List接口的方式和ArrayList类似

1
2
3
4
5
6
7
8
9
List<String> list = new Vector<>();
list.add("hello");
list.add("friends");
list.add(1,"my");

for(String i:list){
System.out.println(i);
}
//与ArrayList相比他多一个输出形式:Enumeration

LinkedList

List的另外一个实现类,如果他向父类向上转型,使用形式和以上两个没有区别,LinkedList底层封装的是一个链表,他的时间复杂度为O(n).
使用LinkedList实现接口

1
2
3
4
5
6
7
8
9
10
11
12
public static void code6(){
List<Persion> list = new LinkedList<>();
list.add(new Persion("Jack",22));
list.add(new Persion("Alice",23));
((LinkedList<Persion>) list).addFirst(new Persion("Alex",21));
((LinkedList<Persion>) list).addLast(new Persion("Tom",25));
list.remove(new Persion("Jack",22));
Iterator<Persion> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}

Set接口集合

Set接口和List接口最大的不同在于Set接口中的内容是不允许重复的.同时需要注意,Set接口并没有对Collection接口进行扩充,而List对Collection进行了扩充.因此,在Set接口中没有get()方法
在Set子接口中有两个常用子类:HashSet(无序存储),TreeSet(有序存储)
同List接口相同,这两个子类并不是直接实现List接口的,而是实现了一个继承自List的抽象类.

HashSet的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void code1(){
Set<String> set = new HashSet<>();
//不按照顺序存储
set.add("hello");
set.add("my");
set.add("friends");
set.add("hello"); //注意:此时已经不能添加重复的对象了
System.out.println(set);
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}

有一点,HashSet是可以存储null的

1
2
3
4
5
6
7
8
public static void code2(){
Set<String> set = new HashSet<>();
set.add(null);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}

TreeSet的使用

1
2
3
4
5
6
7
8
9
10
11
12
Set<String> set = new TreeSet<>();
//按照顺序存储
set.add("B");
set.add("A");
set.add("D");
set.add("C");
set.add("E");

Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

TreeSet排序分析

既然TreeSet子类可以进行排序,所以我们可以利用TreeSet实现数据的排列处理操作,此时要想进行排序实际上是针对于对象数组星星的排序处理,而如果要进行对象数组的排序,对象所在类一定要实现Comparable接口,并且覆写compareTo()方法,只有用过此方法才能知道大小关系
所以在创建对象时一定要继承接口Comparable并且重写compareTo()方法,类的创建如下:

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
class Persion2 implements Comparable<Persion2>{
private String name ;
private Integer age;

public Persion2(String name,Integer age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

@Override
public String toString() {
return "Persion{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}

@Override
public boolean equals(Object obj) {
if(this == obj){
return true;
}

if(obj==null || this.getClass() != obj.getClass()){
return false;
}

Persion2 persion = (Persion2) obj;
if(!this.name.equals(persion.name)){
return false;
}
return this.age.equals(persion.age);
}

@Override
public int hashCode() {
int result = this.name.hashCode();
result = result*31+age.hashCode();
return result;
}

@Override
public int compareTo(Persion2 o) {
if(o == null){
return -1;
}
return this.getAge() - o.getAge();
}

}

将类对象利用TreeSet类进行存储

此处一定注意在类的实现中要覆写compareTo()方法

1
2
3
4
5
6
7
8
9
public static void main(){
Set<Persion2> set = new TreeSet<>();
set.add(new Persion2("Jack",18));
set.add(new Persion2("Cina",19));
set.add(new Persion2("Alex",20));
for(Persion2 i: set){
System.out.println(i);
}
}

我们可以通过我们覆写的compareTo()方法以及Lambda表达式来实现我们想要的对象排序
例如实现对象年龄从小到大排列:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void code5(){
Set<Persion2> set = new TreeSet<>((o1, o2) -> {
if (o1.equals(o2)) {
return 0;
}
//Integer.compareTo
//o1.getAge() - o2.getAge();
return o1.getAge().compareTo(o2.getAge());
});

set.add(new Persion2("Jack",23));
set.add(new Persion2("Marry",18));
set.add(new Persion2("Jerry",19));

for(Persion2 i:set){
System.out.println(i);
}
}

集合输出

Iterator(迭代输出)

Ierator接口中提供了提供了三个方法 –>
hasNext():判断是否有下一个元素
next():取的当前元素
remove():删除元素
先来看一下迭代输出的标准格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void test(){
Set<String> set = new TreeSet<>();
//按照顺序存储
set.add("B");
set.add("A");
set.add("D");
set.add("C");
set.add("E");

Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
String str = iterator.next();
System.out.println(str);
}
}

对于Iterator接口中提供的remove()方法主要解决的就是集合内容的删除操作
删除操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void code3(){
Set<String> set = new TreeSet<>();
//按照顺序存储
set.add("B");
set.add("A");
set.add("D");
set.add("C");
set.add("E");

Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
String str = iterator.next();
if(str.equals("D")){
iterator.remove();
continue;
}
System.out.println(str);

}
}

在进行集合的输出的时候尽量不要进行删除操作

双向迭代(Listlterator)

Iterator输出有一个特点:他只能够由前向后进行内容的迭代处理,而如果想要进行双向迭代,那么就必须依靠Iterator的子接口:Listlterator来实现
Iterator对象接口是由Collection接口支持的,但是ListIterator是由List接口支持的,也就是说,想要使用ListIterator,则需要使用List的实现类来实例化对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
List<String> list = new ArrayList<>();
list.add("Java");
list.add("is");
list.add("best");

ListIterator<String> iterator = list.listIterator();
//从先向后迭代
while(iterator.hasNext()){
String str = iterator.next();
System.out.println(str);
}
//从后向前迭代
while(iterator.hasPrevious()){
String str1 = iterator.previous();
System.out.println(str1);
}

如果想要实现从后向前的迭代,必须先实现从前向后的迭代.否则无法迭代输出内容

Enumeration枚举输出

要是想取得这个接口的实例化对象,只能依靠Vector子类,因为Enumeration最早的设计就是为Vector服务的
使用Enumeration输出

1
2
3
4
5
6
7
8
9
10
11
12
public static void code4(){
Vector<String> list = new Vector<>();
list.add("hello");
list.add("my");
list.add("world");

Enumeration<String> enumeration = list.elements(); //取的接口对象
while(enumeration.hasMoreElements()){ //判断是否有下一个元素
String str = enumeration.nextElement(); //取的元素
System.out.println(str);
}
}

foreach输出

foreach我们之前已经见过,在这里就是想说他不仅可以输出数组,也可以输出集合

1
2
3
4
5
6
7
8
9
10
11
public static void code5(){
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(5);
list.add(7);

for(Integer i:list){
System.out.println(i);
}
}

Map集合

Collection集合的特点是每次进行单个对象的保存,如果现在要进行一对对象的保存就只能使用Map集合来完成,即Map集合中会一次性保存两个对象,且这俩个对象的关系为:Key-Value结构.这种结构的最大特点是可以通过key找到对应的value内容
Map是一个接口,使用Map需要通过他的子类进行实例化,他的实现类有四个:Hashtable,HashMap,TreeHash,ConcurrentHashMap

HashMap子类(常用)

HashMap中的方法

基本使用

1
2
3
4
5
6
7
8
9
10
11
public static void code1(){
Map<String,String> map = new HashMap<>();
map.put("1","Hello");
map.put("2","my");
map.put("3","world");
map.put("1","hello2");

System.out.println(map);
System.out.println(map.get("1"));//通过key(键值)获取对应Vaule元素
System.out.println(map.get("99"));//如果对应键值不存在则会返回
}

获取Map中所有Key的信息

使用方法: KeySet();
需要注意的是这个方法的返回值是一个Set类的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void code2(){
Map<Integer,String> map = new HashMap<>();
map.put(1,"A");
map.put(2,"B");
map.put(3,"C");
map.put(4,"D");
map.put(5,"E");

Set<Integer> set = map.keySet();
Iterator<Integer> iterator = set.iterator();
while(iterator.hasNext()){
Integer str = iterator.next();
System.out.println(str);
}
}

获取Map中所有Value的信息

使用方法:Vaule();
需要注意此方法返回值是一个Collection接口对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void code3(){
Map<Integer,String> map = new HashMap<>();
map.put(1,"A");
map.put(2,"B");
map.put(3,"C");
map.put(4,"D");
map.put(5,"E");

Collection<String> collection = map.values();
Iterator<String> iterator = collection.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}

通过Entry遍历Map

entrySet()方法可以获取所有的K-V的映射关系,即该方法返回的Set表的对象中保存的都是一对一对的K-V集合
使用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void code4(){
Map<Integer,String> map = new HashMap<>();
map.put(1,"A");
map.put(2,"B");
map.put(3,"C");
map.put(4,"D");
map.put(5,"E");

Set<Map.Entry<Integer,String>> set = map.entrySet();
for(Map.Entry<Integer,String> i:set){
//System.out.println(i);
System.out.println(i.getKey() +" = "+i.getValue());
}
}

HashMap源码分析

//TODO

Hashtable

在基本使用上与HashMap类似

1
2
3
4
5
6
7
8
9
10
11
public static void code5(){
Map<String,String> map = new Hashtable<>();
map.put("1","A");
map.put("2","B");
map.put("3","C");
map.put("4","D");
map.put("5","E");
map.put(null,"ad");

System.out.println(map);
}

那么他与HashMap有什么区别呢?以下列举一些他们的区别
1.首先Hashtable是在JDK1.0时提出的,而HashMap是JDK1.2时提出的,我们可以看到Hashtable的命名其实都没有按照标准的双驼峰
2.Hashtable是同步处理,他的性能较低;而HashMap是异步处理,他的性能高
3.Hashtable的线程是安全的,;HashMap的线程是不安全的
4.Hashtable中K和V都不允许为null,如果为空会报出异常;HashMap中K,V允许为空

TreeMap

TreeMap是一个可以排序的Map子类.他是按照Key的内容排序的
先来观察一下TreeMap的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void code6(){
Map<Integer,String> map = new TreeMap<>();
map.put(1,"A");
map.put(5,"E");
map.put(4,"D");
map.put(3,"C");
map.put(2,"B");

Set<Map.Entry<Integer,String>> set = map.entrySet();
Iterator<Map.Entry<Integer, String>> iterator =set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}

TreeMap中的排序处理依然按照的是Comparable接口完成的,判断数据依靠的是compareTo()方法

Map集合使用Iterator输出

在Collection接口中就提供有迭代器的遍历方法,而在Map中是没有直接的Iterator方法的,所以我们就需要先将Map集合转换成Set集合才能够使用迭代器来进行遍历
在Map接口中有一个重要的方法,将Map集合转为Set集合

1
public Set<Map.Entry<K,V>> entrySet();

即Map要想调用Iterator接口输出,走的是一个间接使用的模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void code6(){
Map<Integer,String> map = new TreeMap<>();
map.put(1,"A");
map.put(5,"E");
map.put(4,"D");
map.put(3,"C");
map.put(2,"B");

//获取所有K值
Set<Integer> sett = map.keySet();
Iterator<Integer> iteratorr =sett.iterator();
while(iteratorr.hasNext()){
System.out.println(iteratorr.next());
}

//获取所有键值对
Set<Map.Entry<Integer,String>> set = map.entrySet();
Iterator<Map.Entry<Integer, String>> iterator =set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}

以上就是Map使用Iterator输出的用法
应当注意:
1.Collection保存数据的目的一般用于输出,Map保存数据的目的是为了根据Key查找,找不到返回null
2.Map使用Iterator时一定要注意类的转换(Map.Entry)

栈与队列

Stack栈

栈是一种先进后出的数据结构,浏览器的后退,编辑器的撤销其实都是使用栈来实现的
在Java集合中提供有Stack类,这个类是Vector的子类.但是在我们日常使用中并不使用Vector类中的方法,并且在使用时不要进行向上转型.因为要操作的方法并不是List,而是Stack
查看API,Stack主要有这五个重要的方法

具体使用

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
public class StackTest {

public static void main(String[] args){

Stack<String> stack = new Stack<>();
//入栈
stack.push("A");
stack.push("B");
stack.push("C");
//查看栈顶元素
System.out.println(stack.peek());
//判断栈是否为空,删除栈顶元素
if(!stack.empty()){
stack.pop();
}else{
System.out.println("栈为空");
}
//返回指定元素在栈中的位置(这里是从栈顶开始算起且栈顶为1)
System.out.println(stack.search("B"));

for(String i: stack){
System.out.println(i);
}

//输出方式也可以使用迭代器
Iterator<String> iterator = stack.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}

Queue队列

Queue不同于Stack的是他是先进先出
关于Queue的继承关系: Queue是继承自Collection的,和List,Set都是一个等级的,他的实现类为LinkedList,也很好理解,用链表很容易实现队列的要求(尾插头删实现先进先出)
先来了解一下Queue的一些主要方法

具体使用

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
public class QueueTest {

public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
//进队
queue.add("A");
queue.add("B");
queue.add("C");
queue.add("D");
//这个指定位置插入是LinkedList的方法,所以需要向下转型,不建议使用,因为这会破坏了队列的规则
//((LinkedList<String>) queue).add(2,"X");

//以下两个方法是重复方法,都是查看队列的头元素,但不删除
System.out.println(queue.element());
System.out.println(queue.peek());

//出队,两个方法依然重复
queue.poll();
queue.remove();

for(String i:queue){
System.out.println(i);
}

}
}

队列在整个程序的操作过程中经常被当作缓冲区来使用

Properties属性操作

Preperties类主要用于读取Java的配置文件,各种语言都有自己所支持的配置文件,配置文件中有很多变量是经常改变的,这样做也是为了方便用户,让用户能够脱离程序本身去修改相关的变量设置.这种文件常以*.properties的形式存在,在这种文件里面其内容的保存形式为”key-value”,通过ResourceBundle类可以读取其里面的内容,要想编辑其内容则需要通过Properties类来完成,这个类是专门做属性处理的
Preperties类是Hashtable的子类,定义为

1
public class Properties extends Hashtable<Object,Object>

所有的属性信息实际上都是以字符的形式出现的,在进行属性操作的时候往往会使用Properties类提供的方法完成,下面总结一些常用的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void code1(){
Properties properties = new Properties();
try{
//从输入字节流读取属性列表
//properties.load(new FileInputStream("E:\\JAVA\\新建文件夹12\\12.properties"));
//将此属性列表打印到指定输出流
//properties.list(System.out);
//如果每次都用指定路径的输入流方式难免会造成移植性上的不便,所以在这里使用资源文件加载的方式
//使用getResourceAsStream()
properties.load(PropertiesTest.class.getResourceAsStream("121.properties"));
properties.list(System.out);
//get() 可以通过键值来获取属性
System.out.println(properties.get("1"));
//getProperty() 取的属性,如果键值不存在则返回null
System.out.println(properties.getProperty("1"));
System.out.println(properties.getProperty("1","java"));
properties.setProperty("4","c++");
System.out.println(properties.getProperty("4"));
//指定路径创建一个资源文件
properties.store(new FileWriter("E:\\JAVA\\新建文件夹12\\141.properties"),"这是一段测试");
}catch(Exception e){
e.printStackTrace();
}
}

Collections工具类的使用

Collections是一个集合操作工具类,他可以针对一个集合进行一些操作,使用比较简单,查找api便可

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
public static void code1(){
List<String> list = new ArrayList<>();
//相当于调用了三次add方法
Collections.addAll(list,"A","B","C","D","E");

// //集合反转
// Collections.reverse(list);
//
// //二分查找
// System.out.println(Collections.binarySearch(list,"D"));
//
// Collections.shuffle(list);
//
//// for(int i=65; i<123; i++){
//// list.add(String.valueOf((char)i));
//// }
//
// Collections.fill(list,"X");

// //返回一个空的不可修改的集合对象
// List<String> list2 = Collections.emptyList();
// //如果试图给此表添加数据则会出现UnsupportedOperationException的异常提示
// list2.add("hellow");
// System.out.println(list2);



Iterator<String> iterator = list.listIterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
}