java集合类整理

最新推荐文章于 2021-03-26 05:26:39 发布

baiyang616

最新推荐文章于 2021-03-26 05:26:39 发布

阅读量937

点赞数 1

分类专栏： java 文章标签： java 集合类

本文链接：https://blog.csdn.net/baiyang616/article/details/78525254

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

在学习java的过程中，对于常用的集合类方法进行了一下整理，有的部分借鉴了一下其他人的

1、Arrays用法整理

本文将整理 java.util.Arrays 工具类比较常用的方法：

本文介绍的方法基于JDK 1.7 之上。
1） asList方法
public static <T>List<T> asList(T... a) {

return new ArrayList<>(a);

}

使用该方法可以返回一个固定大小的List，如：
List<String> stringList= Arrays.asList("Welcome", "To","Java","World!");

List<Integer> intList =Arrays.asList(1, 2, 3, 4);

2） binarySearch方法
binarySearch方法支持在整个数组中查找，如：
int index = Arrays.binarySearch(new int[] {1, 2, 3, 4, 5, 6, 7 }, 6);

以及在某个区间范围内查找，如：
public static intbinarySearch(int[] a, int fromIndex, int toIndex,int key)

{

rangeCheck(a.length, fromIndex,toIndex);

return binarySearch0(a, fromIndex,toIndex, key);

}

int index =Arrays.binarySearch(new int[] { 1, 2, 3, 4, 5, 6, 7 }, 1, 6, 6);

3. copyOf及copyOfRange方法

如：
String[] names2 = {"Eric", "John", "Alan", "Liz" };

//[Eric, John, Alan]

String[] copy = Arrays.copyOf(names2, 3);

//[Alan, Liz]

String[] rangeCopy = Arrays.copyOfRange(names2, 2,names2.length);

4. sort方法
String[] names = {"Liz", "John", "Eric", "Alan" };

//只排序前两个

//[John, Liz, Eric, Alan]

Arrays.sort(names, 0, 2);

//全部排序

//[Alan, Eric, John, Liz]

Arrays.sort(names);

另外，Arrays的sort方法也可以结合比较器，完成更加复杂的排序。
public static <T> voidsort(T[] a, Comparator<? super T> c) {

if (LegacyMergeSort.userRequested)

legacyMergeSort(a, c);

else

TimSort.sort(a, c);

}

5. toString方法
Arrays的toString方法可以方便我们打印出数组内容。
如：
String[] names = {"Liz", "John", "Eric", "Alan" };

Arrays.sort(names);

System.out.println(Arrays.toString(names));

控制台将打印出 [Alan,Eric, John, Liz]

6. deepToString方法
如果需要打印二维数组的内容：
int[][] stuGrades = { { 80,81, 82 }, { 84, 85, 86 }, { 87, 88, 89 } };
如果直接用

System.out.println(Arrays.toString(stuGrades));

那么得到的结果类似于
[[I@35ce36,[I@757aef, [I@d9f9c3]}
这个时候得用 deepToString 方法才能得到正确的结果[[80, 81, 82], [84, 85, 86], [87, 88,89]]
System.out.println(Arrays.deepToString(stuGrades));

7. equals方法
使用Arrays.equals来比较1维数组是否相等。
String[] names1 = {"Eric", "John", "Alan", "Liz" };

String[] names2 = { "Eric","John", "Alan", "Liz" };

System.out.println(Arrays.equals(names1,names2));

8. deepEquals方法
Arrays.deepEquals能够去判断更加复杂的数组是否相等。
int[][] stuGrades1 = { { 80,81, 82 }, { 84, 85, 86 }, { 87, 88, 89 } };

int[][] stuGrades2 = { { 80, 81, 82 }, {84, 85, 86 }, { 87, 88, 89 } };

System.out.println(Arrays.deepEquals(stuGrades1,stuGrades2));

9. fill方法
int[] array1 = new int[8];

Arrays.fill(array1, 1);

//[1, 1, 1, 1, 1, 1, 1, 1]

System.out.printl

Java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

² 给数组赋值：通过fill方法。

² 对数组排序：通过sort方法,按升序。

² 比较数组：通过equals方法比较数组中元素值是否相等。

² 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

import java.util.Arrays;

public class TestArrays{

public static void output(int[] array) {

if (array != null) {

for (int i = 0; i< array.length; i++){

System.out.print(array[i] + " ");

}

System.out.println();

}

public static void main(String[] args) {

int[] array = new int[5];

// 填充数组

Arrays.fill(array, 5);

System.out.println("填充数组：Arrays.fill(array, 5)：");

TestArrays.output(array);

// 将数组的第2和第3个元素赋值为8

Arrays.fill(array, 2, 4, 8);

System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");

TestArrays.output(array);

int[] array1 = { 7, 8, 3, 2,12, 6, 3, 5, 4 };

// 对数组的第2个到第6个进行排序进行排序

Arrays.sort(array1, 2, 7);

System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");

TestArrays.output(array1);

// 对整个数组进行排序

Arrays.sort(array1);

System.out.println("对整个数组进行排序：Arrays.sort(array1)：");

TestArrays.output(array1);

// 比较数组元素是否相等

System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "\n" +Arrays.equals(array, array1));

int[] array2 = array1.clone();

System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "\n" +Arrays.equals(array1, array2));

// 使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）

Arrays.sort(array1);

System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)：" + "\n" +Arrays.binarySearch(array1, 3));

// 如果不存在就返回负数

0System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)：" + "\n" +Arrays.binarySearch(array1, 9));

}

输出结果：

填充数组：Arrays.fill(array,5)：
5 5 5 5 5
将数组的第2和第3个元素赋值为8：Arrays.fill(array,2, 4, 8)：
5 5 8 8 5
对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：
7 8 2 3 3 6 12 5 4
对整个数组进行排序：Arrays.sort(array1)：
2 3 3 4 5 6 7 8 12
比较数组元素是否相等:Arrays.equals(array,array1):
false
克隆后数组元素是否相等:Arrays.equals(array1,array2):
true
元素3在array1中的位置：Arrays.binarySearch(array1,3)：
1
元素9在array1中的位置：Arrays.binarySearch(array1,9)：
-9

object类

1、clone()

clone()函数的用途是用来另存一个当前存在的对象。

2、hashCode()和equale()

equale()用于确认两个对象是否相同。
hashCode()用于获取对象的哈希值，这个值的作用是检索，具体的作用可以参考这里
哈希值相同的对象不一定equale()
equale()返回true的两个对象一定相同。

3、toString()和getClass()

toString()返回一个String对象，用来标识自己
getClass()返回一个Class对象，如果打印出来会发现结果是如下格式

因为返回的是一个class对象,后面可以跟class类的方法。用的是谁的构造函数，那么getClass返回的就是谁的类型。
getClass()经常用于java反射机制

4 wait(),wait(long),wait(long,int),notify(),notifyAll()

这几个函数体现的是Java的多线程机制
在使用的时候要求在synchronize语句中使用
wait()用于让当前线程失去操作权限，当前线程进入等待序列
notify()用于随机通知一个持有对象的锁的线程获取操作权限
notifyAll()用于通知所有持有对象的锁的线程获取操作权限
wait(long) 和wait(long,int)用于设定下一次获取锁的距离当前释放锁的时间间隔

5、finalize()

这个函数在进行垃圾回收的时候会用到，匿名对象回收之前会调用到，具体的例子如图所示

java中String类常用方法的使用与实例

方法摘要
`char`	charAt`(int index)` 返回指定索引处的 `char` 值。
`int`	codePointCount`(int beginIndex, int endIndex)` 返回此 `String` 的指定文本范围中的 Unicode 代码点数。
`int`	compareTo`(`String `anotherString)` 按字典顺序比较两个字符串。
`int`	compareToIgnoreCase`(`String `str)` 按字典顺序比较两个字符串，不考虑大小写。
String	concat`(`String `str)` 将指定字符串连接到此字符串的结尾。
`boolean`	contains`(`CharSequence `s)` 当且仅当此字符串包含指定的 char 值序列时，返回 true。
`boolean`	contentEquals`(`CharSequence `cs)` 将此字符串与指定的 `CharSequence` 比较。
`boolean`	contentEquals`(`StringBuffer `sb)` 将此字符串与指定的 `StringBuffer` 比较。
`static` String	copyValueOf`(char[] data)` 返回指定数组中表示该字符序列的 String。
`static` String	copyValueOf`(char[] data, int offset, int count)` 返回指定数组中表示该字符序列的 String。
`boolean`	endsWith`(`String `suffix)` 测试此字符串是否以指定的后缀结束。
`boolean`	equals`(`Object `anObject)` 将此字符串与指定的对象比较。
`boolean`	equalsIgnoreCase`(`String `anotherString)` 将此 `String` 与另一个 `String` 比较，不考虑大小写。
`byte[]`	getBytes`()` 使用平台的默认字符集将此 `String` 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
`byte[]`	getBytes`(`Charset `charset)` 使用给定的 charset 将此 `String` 编码到 byte 序列，并将结果存储到新的 byte 数组。
`void`	getBytes`(int srcBegin, int srcEnd, byte[] dst, int dstBegin)` 已过时。该方法无法将字符正确转换为字节。从 JDK 1.1 起，完成该转换的首选方法是通过 `getBytes()`方法，该方法使用平台的默认字符集。
`byte[]`	getBytes`(`String `charsetName)` 使用指定的字符集将此 `String` 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
`void`	getChars`(int srcBegin, int srcEnd, char[] dst, int dstBegin)` 将字符从此字符串复制到目标字符数组。
`int`	hashCode`()` 返回此字符串的哈希码。
`int`	indexOf`(int ch)` 返回指定字符在此字符串中第一次出现处的索引。
`int`	indexOf`(int ch, int fromIndex)` 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
`int`	indexOf`(`String `str)` 返回指定子字符串在此字符串中第一次出现处的索引。
`int`	indexOf`(`String `str, int fromIndex)` 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
String	intern`()` 返回字符串对象的规范化表示形式。
`boolean`	isEmpty`()` 当且仅当 `length()` 为 `0` 时返回 `true`。
`int`	lastIndexOf`(int ch)` 返回指定字符在此字符串中最后一次出现处的索引。
`int`	lastIndexOf`(int ch, int fromIndex)` 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
`int`	lastIndexOf`(`String `str)` 返回指定子字符串在此字符串中最右边出现处的索引。
`int`	lastIndexOf`(`String `str, int fromIndex)` 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
`int`	length`()` 返回此字符串的长度。
`boolean`	matches`(`String `regex)` 告知此字符串是否匹配给定的正则表达式。
`boolean`	regionMatches`(boolean ignoreCase, int toffset,` String `other, int ooffset, int len)` 测试两个字符串区域是否相等。
`boolean`	regionMatches`(int toffset,` String `other, int ooffset, int len)` 测试两个字符串区域是否相等。
String	replace`(char oldChar, char newChar)` 返回一个新的字符串，它是通过用 `newChar` 替换此字符串中出现的所有 `oldChar` 得到的。
String	replace`(`CharSequence `target,` CharSequence `replacement)` 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String	replaceAll`(`String `regex,` String `replacement)` 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String	replaceFirst`(`String `regex,` String `replacement)` 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
String`[]`	split`(`String `regex)` 根据给定正则表达式的匹配拆分此字符串。
String`[]`	split`(`String `regex, int limit)` 根据匹配给定的正则表达式来拆分此字符串。
`boolean`	startsWith`(`String `prefix)` 测试此字符串是否以指定的前缀开始。
`boolean`	startsWith`(`String `prefix, int toffset)` 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
CharSequence	subSequence`(int beginIndex, int endIndex)` 返回一个新的字符序列，它是此序列的一个子序列。
String	substring`(int beginIndex)` 返回一个新的字符串，它是此字符串的一个子字符串。
String	substring`(int beginIndex, int endIndex)` 返回一个新字符串，它是此字符串的一个子字符串。
`char[]`	toCharArray`()` 将此字符串转换为一个新的字符数组。
String	toLowerCase`()` 使用默认语言环境的规则将此 `String` 中的所有字符都转换为小写。
String	toLowerCase`(`Locale `locale)` 使用给定 `Locale` 的规则将此 `String` 中的所有字符都转换为小写。
String	toString`()` 返回此对象本身（它已经是一个字符串！）。
String	toUpperCase`()` 使用默认语言环境的规则将此 `String` 中的所有字符都转换为大写。
String	toUpperCase`(`Locale `locale)` 使用给定 `Locale` 的规则将此 `String` 中的所有字符都转换为大写。
String	trim`()` 返回字符串的副本，忽略前导空白和尾部空白。
`static` String	valueOf`(boolean b)` 返回 `boolean` 参数的字符串表示形式。
`static` String	valueOf`(char c)` 返回 `char` 参数的字符串表示形式。
`static` String	valueOf`(char[] data)` 返回 `char` 数组参数的字符串表示形式。
`static` String	valueOf`(char[] data, int offset, int count)` 返回 `char` 数组参数的特定子数组的字符串表示形式。
`static` String	valueOf`(double d)` 返回 `double` 参数的字符串表示形式。
`static` String	valueOf`(float f)` 返回 `float` 参数的字符串表示形式。
`static` String	valueOf`(int i)` 返回 `int` 参数的字符串表示形式。
`static` String	valueOf`(long l)` 返回 `long` 参数的字符串表示形式。
`static` String	valueOf`(`Object `obj)` 返回 `Object` 参数的字符串表示形式。

一、创建并初始化字符串

1、使用字符串常量直接初始化 Strings="hello!";

2、使用构造方法创建并初始化 String();//初始化一个对象，表示空字符序列

new String（value）;//利用已存在的字符串常量创建一个新的对象

new String (char[] value);//利用一个字符数组创建一个字符串

new String(char[] value,int offset,intcount);//截取字符数组offset到count的字符创建一个非空串

new String(StringBuffer buffer);//利用StringBuffer对象初始化String对象

二、String类主要方法的使用

1、获取长度 *.length();//这与数组中的获取长度不同，*.length;

2、比较字符串

(1) equals() //判断内容是否相同

(2)compareTo() //判断字符串的大小关系

(3)compareToIgnoreCase(String int) //在比较时忽略字母大小写

(4)== //判断内容与地址是否相同

(5)equalsIgnoreCase()//忽略大小写的情况下判断内容是否相同

　　如果想对字符串中的部分内容是否相同进行比较，可以用

(6)reagionMatches() //有两种 public booleanregionMatches(int toffset, String other,intooffset,int len);表示如果String对象的一个子字符串与参数other的一个子字符串是相同的字符序列，则为true.要比较的String 对象的字符串从索引toffset开始,other的字符串从索引ooffset开始，长度为len。

public Boolean reagionMatches(boolean ignoreCase,inttoffset,String other,int ooffset,intlen);//用布尔类型的参数指明两个字符串的比较是否对大小写敏感。

三、查找字符串中某个位置的字符

public charcharAt(int index);//返回指定索引index位置上的字符，索引范围从0开始.

1. //charAt:通过位置获取内容

2. String str="abcdef";

3. char c=str.charAt(2);

4. System.out.println(c);

四、查找指定字符串在字符串中第一次或最后一词出现的位置

　　在String类中提供了两种查找指定位置的字符串第一次出现的位置的方法

(1)public int indexOf(String str);//从字符串开始检索str，并返回第一次出现的位置，未出现返回-1

(2)public int indexOf(String str,int fromIndex);//从字符串的第fromIndex个字符开始检索str

　　查找最后一次出现的位置有两种方法

(1)public int lastIndexOf(String str);

(2)public int lastIndexOf(String str, int fromIndex);

如果不关心字符串的确切位置则可使用publicboolean contains(CharSequence s);

1. /**

2. * int indexOf(String str)

3. * 返回当给定字符串在当前字符串中的位置

4. * 若当前字符串不包含给定字符串则返回-1

5. * 重载的方法

6. * int indexOf(String str,int formIndex)

7. * @author zc

8. */

9. @Test

10. public void testIndexOf(){

11. // 0123456789012345

12. String str="thinking in java";

13. //查找in

14. int index=str.indexOf("in");

15. System.out.println(index);//2

16. int index2=str.indexOf("ja");

17. int index3=str.indexOf("java");

18. System.out.println(index2);//12

19. System.out.println(index3);//12

20. if(str.indexOf("java")!=-1){

21. String str2=str.replace("ja","jaaa");//thinking in jaaava

22. System.out.println(str2);

23. }

24. //重载 indexOf(str,包含的起始下标),下标可越界

25. int index4=str.indexOf("ja",16);

26. System.out.println("重载的indexOf:"+index4);

27. //lastIndexOf()

28. int index5=str.lastIndexOf("i");

29. System.out.println("最后一个i的下标:"+index5);

30. }

五、检查字符串的起始字符和结束字符

　　开始的字符串两种方法

(1)public boolean starWith(String prefix,int toffset);//如果参数prefix表示的字符串序列是该对象从索引toffset处开始的子字符串，则返回true

(2)public boolean starWith(Stringprefix);

　　结束的字符串方法

(3)publicboolean endsWith(String suffix);

六、截取子串

(1)public String subString(intbeginIndex);

(2)public String subString(int beginIndex,intendIndex);//返回的字符串是从beginIndex开始到endIndex-1的串

"hamburger".substring(4, 8) returns"urge"

"smiles".substring(1, 5) returns"mile"

　　要返回后4位可以这样写Syetem.out.println(*.subString()(*.length()-4));

七、字符串的替换

　　两种方法

(1)public String replace(char oldChar,charnewChar);

(2)public String replace(CharSequencetarget,CharSequence replacement);//把原来的etarget子序列替换为replacement序列，返回新串

(3)public String replaceAll(String regex,Stringreplacement);//用正则表达式实现对字符串的匹配

八、字符串的大小写替转换

(1)publicString toLowerCase(Locale locale);

　　(2)public String toLowerCase();

　　(3)public StringtoupperCase(Locale locale);

(4)public String toUpperCase();

1. public static void main(String[] args) {

2. String str="Hellow World";

3. str=str.toUpperCase();

4. System.out.println(str);

5. str=str.toLowerCase();

6. System.out.println(str);

7. }

九、去除字符串首尾空格

*.trim();

1. String str=" hello ";

2. String trim=str.trim();

3. System.out.println(trim);//hello

十、字符串转换

1、将字符串转换成字符数组

public char[] toCharArray();

2、将字符串转换成字符串数组

public String[] split(String regex);//regex 是给定的匹配

3、将其它数据类型转化为字符串

(1)public static String valueOf(boolean b);

(2)public static String valueOf(char c);

(3)public static String valueOf(int i);

(4)public static String valueOf(long i);

(5)public static String valueOf(float f);

(6)public static String valueOf(double d);

(7)public static String valueOf(char[] data);

(8)public staticString valueOf(Object obj);

1. public static void main(String[] args) {

2. int a=123;

3. //valueOf()性能好一点

4. String str=String.valueOf(a);

5. System.out.println(str);

6. double d=123.123;

7. String str2=String.valueOf(d);

8. //方法2，也可以将一个基本数据类型的数据转成String类型的变量

9. String str3=1234f+"";

10. System.out.println(str3);

11. }

　　可变字符串的创建和初始化

　　两种方法:

public StringBuffer();

public StringBuffer(int caoacity);

StringBuffer类主要方法的使用

a. 构造方法

public StringBuffer() 构造一个字符串缓冲区,构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。

public StringBuffer(int capacity) 构造一个字符串缓冲区,指定容量

public StringBuffer(String str) 将str字符串创建到字符串缓冲区中:str+16

b. 获取方法

public int length() 获取字符串长度

public int capacity() 获取字符串缓冲区的容量大小

c. 添加功能

public StringBuffer append(String str) 表示在字符串缓冲追加,返回字符串缓冲区本身

public StringBuffer insert(int offset,String str) 在指定位置插入str这个字符串,返回缓冲区本身

d. 删除功能

public StringBuffer deleteCharAt(int index) 删除指定索引处的字符,返回的是字符串缓冲区本身

public StringBuffer delete(int start,int end) 删除从指定位置开始,到指定位置结束,返回字符串缓冲区本身

e. 替换功能

public StringBuffer replace(int start,int end,Stringstr) 从指定位置开始到指定位置结束进行替换,替换的内容为新的字符串,返回字符串缓冲区本身

f. 反转功能

public StringBuffer reverse( ) 是StringBuffer的特有功能。★

g. 截取功能

public String substring(int start)

public String substring(int start,int end) 返回的是字符串类型(String),而不是字符串缓冲区本身!

1. StringBuffer常用的构造方法、获取方法

1. public class StringBuffer类的构造方法 {

2. public static void main(String[] args) {

3. //public StringBuffer() :构造一个字符串缓冲区,构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符

4. StringBuffer a = new StringBuffer();

5. System.out.println(a.length());//0

6. System.out.println(a.capacity());//空字符串缓冲区:初始默认容量为16

7. System.out.println("——————————");

8. //public StringBuffer(int capacity):构造一个字符缓存区，指定容量。

9. StringBuffer b = new StringBuffer(50);

10. System.out.println(b.length());//0

11. System.out.println(b.capacity());//50

12. System.out.println("——————————");

13.

14. StringBuffer c = new StringBuffer("HelloWorld");

15. //StringBuffer不能直接赋值；错误写法

16. //StringBuffer c = s ;

17. //StringBuffer c = "HelloWorld";

18.

19. }

2. 添加功能

1. public class StringBuffer类的删除功能 {

2. public static void main(String[] args) {

3. //构建字符串缓冲对象

4. StringBuffer a = new StringBuffer();

5. //添加

6. a.append("Hello");

7. a.append("World");

8. System.out.println(a);//HelloWorld

9. //public StringBuffer deleteCharAt(int index):删除指定索引处的字符,返回的是字符串缓冲区本身

10. a.deleteCharAt(6);

11. System.out.println(a);//HelloWrld

12. a.deleteCharAt(7);

13. System.out.println(a);//HelloWrd

14.

15. ///public StringBuffer delete(int start,int end):删除从指定位置开始,到指定位置结束,返回字符串缓冲区本身

16. System.out.println("——————————");

17.

18. StringBuffer b = new StringBuffer("LinkinPark");

19. b.delete(3, 6);

20. System.out.println(b);//LinPark

21. }

3. 删除功能

例：

[java] view plain copy

print ?

1. public class StringBuffer类的替换_反转_截取 {

2. public static void main(String[] args) {

3. //字符串替换；

4. //创建字符缓冲区对象

5. StringBuffer a = new StringBuffer();

6. //最加字符串：

7. a.append("Hello").append("World");

9. System.out.println(a);

10. //public StringBuffer replace(int start,int end,String str)从指定位置开始到指定位置结束进行替换,替换的内容为一个新的字符串,返回字符串缓冲区本身

11. a.replace(2, 6, "WHAT");

12. System.out.println(a);//HeWHATorld;

13.

14. //字符串反转；

15. StringBuffer b = new StringBuffer("LinkinPark");

16. b.reverse();

17. System.out.println(b);//kraPnikniL

18.

19. //字符串截取功能；返回的是新的字符串类型,而不是字符串缓冲区本身!

20. StringBuffer c = new StringBuffer("ImagineDragons");

21. String d = c.substring(7);

22. System.out.println(d);//Dragons

23. }

24. }

4. 替换功能、反转功能、截取功能

1. public class StringBuffer类的替换_反转_截取 {

2. public static void main(String[] args) {

3. //字符串替换；

4. //创建字符缓冲区对象

5. StringBuffer a = new StringBuffer();

6. //最加字符串：

7. a.append("Hello").append("World");

9. System.out.println(a);

10. //public StringBuffer replace(int start,int end,String str)从指定位置开始到指定位置结束进行替换,替换的内容为一个新的字符串,返回字符串缓冲区本身

11. a.replace(2, 6, "WHAT");

12. System.out.println(a);//HeWHATorld;

13.

14. //字符串反转；

15. StringBuffer b = new StringBuffer("LinkinPark");

16. b.reverse();

17. System.out.println(b);//kraPnikniL

18.

19. //字符串截取功能；返回的是新的字符串类型,而不是字符串缓冲区本身!

20. StringBuffer c = new StringBuffer("ImagineDragons");

21. String d = c.substring(7);

22. System.out.println(d);//Dragons

23. }

24. }

StringBuilder类的常用方法

1、StringBuilder append(参数)--将追加内容到当前StringBuilder对象的末尾；

2、StringBuilder insert(位置，参数)--将内容插入到StringBuilder对象的指定位置；

3、String toString()--将SringBuilder 对象转换为String对象；

4、int length()--获取字符串的长度；

String --字符串常量；

StringBuffer--字符串变量（线程安全）；

StringBuilder--字符串变量（非线程安全）；

程序运行时会额外创建一个对象，保存 "helloworld"。当频繁操作字符串时，就会额外产生很多临时变量。使用 StringBuilder 或 StringBuffer 就可以避免这个问题。至于 StringBuilder 和StringBuffer ，它们基本相似，不同之处，StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此一般情况下，如果需要创建一个内容可变的字符串对象，应优先考虑使用 StringBuilder 类。

代码：

// 创建StringBuilder对象，存储字符串
StringBuilder str=newStringBuilder("hello");
// 在字符串后面追加字符串
str.append("imooc");
// 在字符串后面追加整数
str.append("38483");
// 输出字符串长度
System.out.println("字符串长度：" + str.length());
// 插入前字符串
System.out.println("插入前：" + str);
// 在指定的位置插入
str.insert(4, "!");
// 转换指定位置插入内容
String str=str.toString();
System.out.println("插入后：" + str1);

Java中字符数组、String类、StringBuffer三者的相互转换

一、StringBuffer与String的相互转换

1、将StringBuffer转换成String

StringBuffer类成员toString函数可将其转换成String类型。

StringBuffer buffer = new StringBuffer(“abcd”);

String str = buffer.toString();

通过String类中的构造将一个StringBuffer类转换为String类：String(StringBuffer buffer)

StringBuffer buffer= new StringBuffer(“abcd”);

String str = new String(buffer);

2、将String转换成StringBuffer

方式一：利用构造函数

String str=“HelloWorld.”;
StringBuffer buffer = newStringBuffer(str);

方式二：调用append函数

String str=“HelloWorld.”;
StringBuffer buffer = newStringBuffer();
buffer.append(str);

二、String与字符数组的相互转换

1、将String转换成字符数组

String类成员toCharArray函数可将其转换成字符数组。

String str = “Hello World.”;// 创建一个String对象
char[] ch = str.toCharArray();// 再调用String对象的toCharArray函数转换成字

2、将字符数组转换成String

方法1：利用String类的构造函数，直接在构造String时完成转换。

char[] data = {'a', 'b', 'c'};
String str = new String(data);

方法2：调用String类的valueOf函数转换。

String.valueOf(char[] ch);

三、将StringBuffer与字符数组的相互转换

1、将StringBuffer转换成字符数组

在Java中不支持直接从StringBuffer转换成字符数组。而是先将StringBuffer转换成String，

然后由String调用toCharArray函数转换成字符数组。

StringBuffer stringBuffer= new StringBuffer(“Hello World.”);

String str =stringBuffer.toString();// 先将StringBuffer对象转换成String对象

char[] ch =str.toCharArray();// 再调用String对象的toCharArray函数转换成字符数组

2、将字符数组转换成StringBuffer与将StringBuffer转换成字符数组类似，需要先将字符数组转换成String，然后再由String转换成StringBuffer。

char[] data = {'H', 'e', 'l','l', 'o', 'd'};

String str = new String();//或者直接调用构造方法：String

str = new String(data);

str = String.valueOf(data);//调用String类的valueOf函数将字符数组转换成String

StringBuffer buffer = new StringBuffer();

buffer = buffer.append(str);//调用append函数将String转换成Stringbuffer

java.lang.Math类中的方法

java.lang.Math类中包含E和PI两个静态常量，以及进行科学计算的类(static)方法，可以直接通过类名调用。

public static final Double E =2.7182818284590452354

public static final Double PI =3.14159265358979323846

public static long abs(double x)：传回 x 的绝对值。X也可int long float

publicstatic long floor(double x)：传回不大于x的最大整数值，向下取整

public static long ceil(double x)：传回不小于x的最小整数值。，向上取整

public static long exp(double x)：传回相当于e^x

public static long log(double x)：传回x的自然对数函数值

public static long max(double x,double y)：传回x、y较大数

public static long min(double x,double y)：传回x、y较小数

publicstatic long pow(double x,double y)：传回x的y次幂值

public static long sqrt(double x):传回x开平方值

publicstatic long rint(double x):传回最接近x的整数值

public static long round(double x):传回x的四舍五入值

public static long random():传回随机数值,产生一个0-1之间的随机数(不包括0和1)

public class MathDemo {
public static void main(String args[]){
/**
* abs求绝对值
*/
System.out.println(Math.abs(-10.4)); //10.4
System.out.println(Math.abs(10.1)); //10.1
/**
* ceil天花板的意思，就是返回大的值，注意一些特殊值
*/
System.out.println(Math.ceil(-10.1)); //-10.0
System.out.println(Math.ceil(10.7)); //11.0
System.out.println(Math.ceil(-0.7)); //-0.0
System.out.println(Math.ceil(0.0)); //0.0
System.out.println(Math.ceil(-0.0)); //-0.0
/**
* floor地板的意思，就是返回小的值
*/
System.out.println(Math.floor(-10.1)); //-11.0
System.out.println(Math.floor(10.7)); //10.0
System.out.println(Math.floor(-0.7)); //-1.0
System.out.println(Math.floor(0.0)); //0.0
System.out.println(Math.floor(-0.0)); //-0.0
/**
* max 两个中返回大的值,min和它相反，就不举例了
*/
System.out.println(Math.max(-10.1, -10)); //-10.0
System.out.println(Math.max(10.7, 10)); //10.7
System.out.println(Math.max(0.0, -0.0)); //0.0
/**
* random 取得一个大于或者等于0.0小于不等于1.0的随机数
*/
System.out.println(Math.random()); //0.08417657924317234
System.out.println(Math.random()); //0.43527904004403717
/**
* rint 四舍五入，返回double值
* 注意.5的时候会取偶数
*/
System.out.println(Math.rint(10.1)); //10.0
System.out.println(Math.rint(10.7)); //11.0
System.out.println(Math.rint(11.5)); //12.0
System.out.println(Math.rint(10.5)); //10.0
System.out.println(Math.rint(10.51)); //11.0
System.out.println(Math.rint(-10.5)); //-10.0
System.out.println(Math.rint(-11.5)); //-12.0
System.out.println(Math.rint(-10.51)); //-11.0
System.out.println(Math.rint(-10.6)); //-11.0
System.out.println(Math.rint(-10.2)); //-10.0
/**
* round 四舍五入，float时返回int值，double时返回long值
*/
System.out.println(Math.round(10.1)); //10
System.out.println(Math.round(10.7)); //11
System.out.println(Math.round(10.5)); //11
System.out.println(Math.round(10.51)); //11
System.out.println(Math.round(-10.5)); //-10
System.out.println(Math.round(-10.51)); //-11
System.out.println(Math.round(-10.6)); //-11
System.out.println(Math.round(-10.2)); //-10
}
}

NumberFormat类：(public abstract classNumberFormat extends Format)

用java.text.NumberFormat类对输出的数字结果进行必要的格式化。

使用该类如下方法类实例化一个NumberFormat对象：

public static final NumberFormatgetInstance()

然后用该对象调用如下方法可以格式化数字number(返回字符串对象)：

public final String format(double number)

NumberFormat类有如下常用方法：

public void setMaximumFractionDigits(intnewValue)//设置数的小数部分所允许的最大位数。

public void setMaximumIntegerDigits(intnewValue)//设置数的整数部分所允许的最大位数。

public void setMinimumFractionDigits(intnewValue)//设置数的小数部分所允许的最小位数。

public void setMinimumIntegerDigits(intnewValue)//设置数的整数部分所允许的最小位数。

(更多方法及用法看JDK6API参考。)

BigInteger类、

java.math包中的BigInteger类和BigDecimal类分别提供任意精度的整数和小数运算。

两个类设计思想一样，这里只对BigInterger类稍做介绍，细节可以查看JDK6API参考。

构造方法如下：

BigInteger(String val) //将 BigInteger 的十进制字符串表示形式转换为 BigInteger。

还有很多考虑周全的构造函数，建议要准备写特殊需求的BigInteger前先认真翻下JDK。

常用方法：

abs() //返回其值是此BigInteger的绝对值的BigInteger。

add(BigInteger val) //返回其值为(this+val)的BigInteger。

subtract(BigInteger val) //返回其值为(this-val)的BigInteger。

multiply(BigInteger val) // 返回其值为(this*val)的BigInteger。

divide(BigInteger val) //返回其值为(this/val)的BigInteger。

remainder(BigInteger val) //返回其值为(this%val)的BigInteger。

compareTo(BigInteger val) //将此BigInteger与指定的BigInteger进行比较。返回值1、0、-1分别表示大于、等于、小于

pow(int exponent) //返回当前大数的exponent次幂。

toString() //返回此BigInteger的十进制字符串表示形式。

toString(int radix) //返回此BigInteger的给定基数(radix进制)的字符串表示形式。

1. package com.xujin;

2. import java.util.*;

3. import java.math.*;

4. public class Test {

5. public static void main(String[] args) {

6. Scanner cin = new Scanner(System.in);

8. //BigInteger类型的常量

9. BigInteger A = BigInteger.ONE;

10. System.out.println("BigInteger.ONE的结果为 " + A);//1

11. BigInteger B = BigInteger.TEN;

12. System.out.println("BigInteger.TEN的结果为 " + B);//10

13. BigInteger C = BigInteger.ZERO;

14. System.out.println("BigInteger.ZERO的结果为 " + C);//0

15.

16. //初始化

17. BigInteger c = new BigInteger("12345670",8);//c = 01234567890 ，八进制

18. System.out.println(c);//2739128

19. BigInteger d = BigInteger.valueOf(100);//d = 100

20. BigInteger e = new BigInteger(new byte[]{1,0});//00000001 00000000

21. System.out.println(e);//256

22. System.out.println(e.bitCount());

23. System.out.println(e.bitLength());

24.

25. //运算

26. System.out.println("请输入大整数a，b");

27. while (cin.hasNext()) {//等同于!=EOF

28. BigInteger a = cin.nextBigInteger();

29. BigInteger b = cin.nextBigInteger();

30. BigInteger c1 = a.add(b); // 大数加法

31. System.out.println("加的结果为 " + c1);

32. BigInteger c2 = a.subtract(b); // 大数减法

33. System.out.println("减的结果为 " + c2);

34. BigInteger c3 = a.multiply(b); // 大数乘法

35. System.out.println("乘的结果为 " + c3);

36. BigInteger c4 = a.divide(b); // 大数除法

37. System.out.println("除的结果为 " + c4);

38. BigInteger c5 = a.mod(b);

39. System.out.println("模的结果为 " + c5);

40. BigInteger cc5 = a.remainder(b);

41. System.out.println("余的结果为 " + cc5);

42. BigInteger c6 = a.max(b);// 取最大

43. System.out.println("最大为 " + c6);

44. BigInteger c7 = a.min(b); // 取最小

45. System.out.println("最小为 " + c7);

46. BigInteger c8 = a.pow(10); //指数运算

47. System.out.println("指数运算结果为" + c8);

48. if (a.equals(b)) // 判断是否相等

49. System.out.println("相等");

50. else

51. System.out.println("不相等");

52. BigInteger c10 = a.abs(); // 求绝对值

53. System.out.println("a的绝对值为 " + c10);

54. BigInteger c11 = a.negate(); // 求相反数

55. System.out.println("a的相反数为 " + c11);

56. }

57. }

58. }

BigDecimal类：

方法摘要
BigDecimal	abs`()` 返回 `BigDecimal`，其值为此 `BigDecimal` 的绝对值，其标度为 `this.scale()`。
BigDecimal	add`(`BigDecimal `augend)` 返回一个 `BigDecimal`，其值为 `(this + augend)`，其标度为 `max(this.scale(), augend.scale())`。
`int`	compareTo`(`BigDecimal `val)` 将此 `BigDecimal` 与指定的 `BigDecimal` 比较。
BigDecimal	divide`(`BigDecimal `divisor)` 返回一个 `BigDecimal`，其值为 `(this / divisor)`，其首选标度为 `(this.scale() - divisor.scale())`；如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 `ArithmeticException`。
`double`	doubleValue`()` 将此 `BigDecimal` 转换为 `double`。
`boolean`	equals`(`Object `x)` 比较此 `BigDecimal` 与指定的 `Object` 的相等性。
`float`	floatValue`()` 将此 `BigDecimal` 转换为 `float`。
`int`	hashCode`()` 返回此 `BigDecimal` 的哈希码。
`int`	intValue`()` 将此 `BigDecimal` 转换为 `int`。
`long`	longValue`()` 将此 `BigDecimal` 转换为 `long`。
BigDecimal	multiply`(`BigDecimal `multiplicand)` 返回一个 `BigDecimal`，其值为 `(this × multiplicand)`，其标度为 `(this.scale() + multiplicand.scale())`。
BigDecimal	pow`(int n)` 返回其值为 `(thisⁿ)` 的 `BigDecimal`，准确计算该幂，使其具有无限精度。
BigDecimal	remainder`(`BigDecimal `divisor)` 返回其值为 `(this % divisor)` 的 `BigDecimal`。
BigDecimal	remainder`(`BigDecimal `divisor,` MathContext `mc)` 返回其值为 `(this % divisor)` 的 `BigDecimal`（根据上下文设置进行舍入）。
BigDecimal	round`(`MathContext `mc)` 返回根据 `MathContext` 设置进行舍入后的 `BigDecimal`。
BigInteger	toBigInteger`()` 将此 `BigDecimal` 转换为 `BigInteger`。
String	toString`()` 返回此 `BigDecimal` 的字符串表示形式，如果需要指数，则使用科学记数法。
`static` BigDecimal	valueOf`(double val)` 使用 `Double.toString(double)` 方法提供的 `double` 规范的字符串表示形式将 `double` 转换为 `BigDecimal`。
`static` BigDecimal	valueOf`(long val)` 将 `long` 值转换为具有零标度的 `BigDecimal`。
`static` BigDecimal	valueOf`(long unscaledVal, int scale)` 将 `long` 非标度值和 `int` 标度转换为 `BigDecimal`。

//创建BigDecimal对象

BigDecimal bigNumber = new BigDecimal("89.1234567890123456789");

BigDecimal bigRate = new BigDecimal(1000);

BigDecimal bigResult = new BigDecimal();//对象bigResult的值为0.0

注意，BigDecimal中的divide函数和BigInteger中的稍有不同。

方法１：pubilc BigDecimal divide(BigDecimal divisor)

ＡＰＩ中的解释：返回一个 BigDecimal，其值为 (this / divisor)，其首选标度为 (this.scale() - divisor.scale())；如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 ArithmeticException。

方法２：
pubilc BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

scale指的是小数点后的位数。比如123.456则scale就是3，是BigDecimal类中的方法啊。

如:BigDecimal b = new BigDecimal("123.456")；

//b.scale(),返回的就是3.
　　roundingMode是小数的保留模式。它们都是BigDecimal中的常量字段。

比如：BigDecimal.ROUND_HALF_UP表示的就是4舍5入。

pubilc BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
的意思是说：我用一个BigDecimal对象除以divisor后的结果，并且要求这个结果保留有scale个小数位，roundingMode表示的就是保留模式，是四舍五入啊还是其它的，你可以自己选！

方法３：
pubilc BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)

与上面的大整数同样的函数：

1. package com.xujin;

3. import java.util.*;

4. import java.math.*;

6. public class Test {

7. public static void main(String[] args) {

8. Scanner cin = new Scanner(System.in);

10. //BigDecimal类型的常量

11. BigDecimal A = BigDecimal.ONE;

12. System.out.println("BigDecimal.ONE的结果为 " + A);//1

13. BigDecimal B = BigDecimal.TEN;

14. System.out.println("BigDecimal.TEN的结果为 " + B);//10

15. BigDecimal C = BigDecimal.ZERO;

16. System.out.println("BigDecimal.ZERO的结果为 " + C);//0

17.

18. //初始化

19. BigDecimal c = new BigDecimal("89.1234567890123456789");

20. BigDecimal d = new BigDecimal(100);

21. BigDecimal e = new BigDecimal(new char[]{'2','1','.','2'});

22. System.out.println(e);//21.2

23.

24. //运算

25. System.out.println("请输入大整数a，b");

26. while (cin.hasNext()) {//等同于!=EOF

27. BigDecimal a = cin.nextBigDecimal();

28. BigDecimal b = cin.nextBigDecimal();

29. BigDecimal c1 = a.add(b); // 大数加法

30. System.out.println("加的结果为 " + c1);

31. BigDecimal c2 = a.subtract(b); // 大数减法

32. System.out.println("减的结果为 " + c2);

33. BigDecimal c3 = a.multiply(b); // 大数乘法

34. System.out.println("乘的结果为 " + c3);

35.

36. //注意，这里如果不能除尽，就会抛出一个ArithmeticException错误

37. BigDecimal c4 = a.divide(b); // 大数除法

38. System.out.println("除的结果为 " + c4);

39.

40. BigDecimal cc5 = a.remainder(b);

41. System.out.println("余的结果为 " + cc5);

42. BigDecimal c6 = a.max(b);// 取最大

43. System.out.println("最大为 " + c6);

44. BigDecimal c7 = a.min(b); // 取最小

45. System.out.println("最小为 " + c7);

46. BigDecimal c8 = a.pow(10); //指数运算

47. System.out.println("指数运算结果为" + c8);

48. if (a.equals(b)) // 判断是否相等

49. System.out.println("相等");

50. else

51. System.out.println("不相等");

52. BigDecimal c10 = a.abs(); // 求绝对值

53. System.out.println("a的绝对值为 " + c10);

54. BigDecimal c11 = a.negate(); // 求相反数

55. System.out.println("a的相反数为 " + c11);

56. }

57. }

58. }

实用格式转换：

1.  //去后缀0

2.    BigDecimal bd = new BigDecimal("12000.87300");

3.    bd = bd.stripTrailingZeros();

4.    System.out.println(bd);

5.    bd = new BigDecimal("1.2E-3");

6.  //  bd = new BigDecimal("1.2E+3");

7.    //去科学记数

8.    if(bd.scale()<0){

9.     bd = bd.setScale(0);

10.   }

11.   System.out.println(bd);

12.   //保留N位小数.  N=5:

13.   bd = new BigDecimal("12000.873000");

14.   bd = bd.setScale(5, BigDecimal.ROUND_HALF_UP);

15.   System.out.println(bd);

JAVA随机数生成 | Math.random()方法 | 随机生成int、double类型

要获取一个[x,y)的double类型的随机数 | 左闭右开

double d = x + Math.random() *(y - x);

要获取一个(x,y]的double类型的随机数 | 左开右闭

double d = y - Math.random() *(y - x);

要获取一个[x,y]的double类型的随机数 | 左闭右闭

double d = x + Math.random() *y % (y - x + 1);

要获取一个(x,y)的double类型的随机数 | 左开右开

double d = (y - Math.random())% y;

要获取一个[x,y)的int类型的随机数 | 左闭右开

int d = x + (int)(Math.random()* (y - x));

要获取一个(x,y]的int类型的随机数 | 左开右闭

int d = y - (int)(Math.random()* (y - x));

要获取一个[x,y]的int类型的随机数 | 左闭右闭

int i = x + (int)(Math.random()* (y - x + 1));

要获取一个(x,y)的int类型的随机数 | 左开右开

int d = (int)((y -Math.random()) % y);

注意1

Random r = new Random();

double rs = r.nextDouble();

int in = r.nextInt(500);

提供另一种解决思路

注意2

Math类中有一floor(double a)方法

public static doublefloor(double a)

返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。

所以对于要获取一个[x,y]的double类型的随机数 | 左闭右闭时候

可以采用以下解决思路：

Double.valueOf( x +Math.floor(random.nextDouble() * y % (y - x + 1));

1. package lkl2;

3. import java.util.Arrays;

4. import java.util.Random;

5. import java.util.concurrent.ThreadLocalRandom;

7. //java 随机数生成类 Random

8. public class RandomTest {

9. public static void main(String[] args){

10. //先建一个对象

11. //可以提供一个随机数种子，默认是系统时间

12. Random rand = new Random();

13.

14. //布尔型随机数

15. System.out.println("rand.nextBoolean"+rand.nextBoolean());

16. byte[] buffer = new byte[16];

17.

18. //为一个byte数组赋随机数

19. rand.nextBytes(buffer);

20. System.out.println(Arrays.toString(buffer));

21.

22. //生成0.0～1.0之间的伪随机数

23. System.out.println("rand.nextDouble："+rand.nextDouble());

24.

25. //生成0.0～1.0之间的伪随机数

26. System.out.println("rand.nextFloat:"+rand.nextFloat());

27.

28. //生成一个整数取值范围内的伪随机数

29. System.out.println("rand.nextInt:"+rand.nextInt());

30.

31. //生成一个0~26之间的伪随机数

32. System.out.println("rand.nextInt(26)："+rand.nextInt(26));

33.

34. //生成一个long整数取值范围的伪随机数

35. System.out.println("rand.nextLong()："+rand.nextLong());

36. }

37.

38. }

Collection泛型接口

Collection

|-----List 有序(存储顺序和取出顺序一致)，可重复

|----ArrayList ，线程不安全，底层使用数组实现，查询快，增删慢。效率高。每次容量不足时，自增长度的一半，如下源码可知

int newCapacity = oldCapacity + (oldCapacity >> 1);

|----LinkedList ，线程不安全，底层使用链表实现，查询慢，增删快。效率高

|----Vector ，线程安全，底层使用数组实现，查询快，增删慢。效率低每次容量不足时，默认自增长度的一倍（如果不指定增量的话），如下源码可知

int newCapacity = oldCapacity+ ((capacityIncrement > 0) ?

capacityIncrement : oldCapacity);

|-----Set 元素唯一，一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和e2，并且最多包含一个 null 元素。

|--HashSet 底层是由HashMap实现的，通过对象的hashCode方法与equals方法来保证插入元素的唯一性，无序(存储顺序和取出顺序不一致)，。

|--LinkedHashSet 底层数据结构由哈希表和链表组成。哈希表保证元素的唯一性，链表保证元素有序。(存储和取出是一致)

|--TreeSet 基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的

方法摘要

boolean

add(E e)
确保此 collection 包含指定的元素（可选操作）。

boolean

addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

void

clear()
移除此 collection 中的所有元素（可选操作）。

boolean

contains(Object o)
如果此 collection 包含指定的元素，则返回 true。

boolean

containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。

boolean

equals(Object o)
比较此 collection 与指定对象是否相等。

int

hashCode()
返回此 collection 的哈希码值。

boolean

isEmpty()
如果此 collection 不包含元素，则返回 true。

Iterator<E>

iterator()
返回在此 collection 的元素上进行迭代的迭代器。

boolean

remove(Object o)
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。

boolean

removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

boolean

retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

int

size()
返回此 collection 中的元素数。

Object[]

toArray()
返回包含此 collection 中所有元素的数组。

<T> T[]

toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

public class CollectionReview {

public static void main(String[]args) {

test1();

}

private static void test1() {

Collection<String>collection = new Vector<>();

collection.add("gogogo");

collection.add("pap");

collection.add("niko");

collection.add("kitty");

Collection<String>coll = new ArrayList<>();

coll.add("niko");

coll.add("kitty");

coll.add("pecuyu");

// collection.clear(); // 清空集合

//System.out.println(collection.isEmpty()); // 集合是否为空

// int size = collection.size(); // 获取集合大小

// System.out.println(size);

// boolean contains =collection.contains("niko"); // 是否包含另一个元素

// System.out.println(contains);

//boolean containsAll =collection.containsAll(coll); //是否完全包含另一个集合

//System.out.println(containsAll);

// collection.remove("kitty"); // 删除第一个匹配项，删除了匹配项则返回true

// boolean removeAll =collection.removeAll(coll); //删除与指定集合有交集的部分，原集合有改变就返回true

// System.out.println(removeAll);

//boolean retainAll =collection.retainAll(coll);// 保留与指定集合有交集的部分，原集合有改变就返回true

//System.out.println(retainAll);

// iterator 迭代器，方式1

Iterator<String>iterator = collection.iterator();

while(iterator.hasNext()){

System.out.print(iterator.next()+" ");

}

System.out.println("\n"+"-------------------");

// 方式2，for循环完iterator1就会被销毁，节约内存提高效率

for (Iterator<String>iterator1 = collection.iterator(); iterator1.hasNext(); ) {

System.out.print(iterator1.next()+" ");

}

System.out.println("\n"+"-------------------");

Object[] array = collection.toArray(); // 转化为object数组

for (Object string : array){

System.out.print(string+" ");

}

System.out.println("\n"+"-------------------");

String[] arr=newString[collection.size()];

String[] array2 = collection.toArray(arr); //指定要转化的数组类型

for (String string : array2){

System.out.print(string+" ");

}

List泛型接口

方法摘要

boolean

add(E e)
向列表的尾部添加指定的元素（可选操作）。

void

add(int index, E element)
在列表的指定位置插入指定元素（可选操作）。

boolean

addAll(Collection<? extends E> c)
添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。

boolean

addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

void

clear()
从列表中移除所有元素（可选操作）。

boolean

contains(Object o)
如果列表包含指定的元素，则返回 true。

boolean

containsAll(Collection<?> c)
如果列表包含指定 collection 的所有元素，则返回 true。

boolean

equals(Object o)
比较指定的对象与列表是否相等。

get(int index)
返回列表中指定位置的元素。

int

hashCode()
返回列表的哈希码值。

int

indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

boolean

isEmpty()
如果列表不包含元素，则返回 true。

Iterator<E>

iterator()
返回按适当顺序在列表的元素上进行迭代的迭代器。

int

lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

ListIterator<E>

listIterator()
返回此列表元素的列表迭代器（按适当顺序）。

ListIterator<E>

listIterator(int index)
返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。

remove(int index)
移除列表中指定位置的元素（可选操作）。

boolean

remove(Object o)
从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。

boolean

removeAll(Collection<?> c)
从列表中移除指定 collection 中包含的其所有元素（可选操作）。

boolean

retainAll(Collection<?> c)
仅在列表中保留指定 collection 中所包含的元素（可选操作）。

set(int index, E element)
用指定元素替换列表中指定位置的元素（可选操作）。

int

size()
返回列表中的元素数。

List<E>

subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。

Object[]

toArray()
返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。

<T> T[]

toArray(T[] a)
返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

ArrayList类

1 构造方法

ArrayList()

      构造一个初始容量为 10 的空列表（每次递增容量的一半）

ArrayList(Collection<? extends E> c)

      构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的

ArrayList(int initialCapacity)

    构造一个具有指定初始容量的空列表

2 特有方法(相对于List)

void ensureCapacity(int minCapacity)

     如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。

 protected  voidremoveRange(int fromIndex, int toIndex)

          移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。

ArrayList使用示例

publicclassArrayListReview {

publicstaticvoid main(String[] args) {

ArrayList<Info> infosList=newArrayList<>();

infosList.add(newInfo(0, "aaa"));

infosList.add(newInfo(1, "bbb"));

infosList.add(newInfo(2, "ccc"));

infosList.add(newInfo(3, "ddd"));

infosList.add(1, newInfo(4, "eee")); // 按索引插入到指定位置

// foreach遍历输出

for (Info info : infosList) {

System.out.println(info);

}

System.out.println("------------------------");

// 截取字串

List<Info> subList =infosList.subList(1, 3);

subList.add(newInfo(30, "fly"));

printList(subList);

ArrayList<Info> newInfosList=newArrayList<>();

newInfosList.add(newInfo(11, "qqq"));

newInfosList.add(newInfo(12, "www"));

ArrayList<String> ss=newArrayList<>();

// infosList.addAll(newInfosList);

// 添加一个指定集合到原集合最后，注意两个集合的泛型参数一致

infosList.addAll(2,newInfosList); // 将指定集合插入到指定位置

//printList(infosList);

Info info = infosList.get(2); // 取出指定位置的元素

System.out.println(info);

infosList.set(0, newInfo(10, "rrr")); // 替换指定索引位置的元素

//printList(infosList);

//根据元素获取元素第一次出现的索引，不存在则返回-1

int index =infosList.indexOf(info);

int lastIndex = infosList.lastIndexOf(info); // 取出元素的最后一个匹配项的索引

int indexOf = infosList.indexOf(newInfo(4,"eee")); // 重写了Info类的hashCode与equals方法，用于判断两个对象是否相同

System.out.println("index="+indexOf);

//printList(infosList);

// 通过反射拿到的removeRange方法

removeRange(infosList, 1, 3);

//printList(infosList);

// listIterator从前往后迭代

ListIterator<Info> listIterator =infosList.listIterator();

while(listIterator.hasNext()){

// 最后抛出错误，java.util.NoSuchElementException，不要每次取都掉用next方法，它每调用一次，迭代器指针向前移动一位

//System.out.println("id="+listIterator.next().getId()

//+"adress="+listIterator.next().getAdress());

Info next =listIterator.next(); // 正确做法，调用一次要取出元素，然后操作属性

System.out.println("id="+next.getId()

+" adress="+next.getAdress());

}

// 往前迭代，必须在往后迭代之后用

while(listIterator.hasPrevious()){ // 当有上一个元素时

Info previous = listIterator.previous(); // 获取上一个元素

System.out.println("id="+previous.getId()+" adresss="+previous.getAdress());

}

// 通过数组来转化成一个List，虽然可以把数组转成集合，但是集合的长度不能改变。

String[] a=newString[]{"hello","world","just","do","it"};

List<String> asList =Arrays.asList(a);

//asList.add("gogogo"); //不可修改asList，会抛出UnsupportedOperationException

// 泛型使用

// ArrayList<Object> l=new ArrayList<String>();// 不行

// ArrayList<ArrayList> lll=new ArrayList<List>(); // 不行

// ArrayList<List> lll=new ArrayList<ArrayList>(); // 不行

// ArrayList l=newArrayList<String>(); // 可行

// ArrayList<String> l=new ArrayList<>(); // 可行

// ArrayList ll=newArrayList(); // 可行

}

// 打印输出

publicstatic<E> void printList(List<E> list) {

for (E e : list) {

System.out.println(e);

}

System.out.println("------------------------");

}

LinkedList使用详解

方法摘要

boolean

add(E e)
将指定元素添加到此列表的结尾。

void

add(int index, E element)
在此列表中指定的位置插入指定的元素。

boolean

addAll(Collection<? extends E> c)
添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。

boolean

addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素从指定位置开始插入此列表。

void

addFirst(E e)
将指定元素插入此列表的开头。

void

addLast(E e)
将指定元素添加到此列表的结尾。

void

clear()
从此列表中移除所有元素。

Object

clone()
返回此 LinkedList 的浅表副本。

boolean

contains(Object o)
如果此列表包含指定元素，则返回 true。

Iterator<E>

descendingIterator()
返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。

element()
获取但不移除此列表的头（第一个元素）。

get(int index)
返回此列表中指定位置处的元素。

getFirst()
返回此列表的第一个元素。

getLast()
返回此列表的最后一个元素。

int

indexOf(Object o)
返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

int

lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

ListIterator<E>

listIterator(int index)
返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。

boolean

offer(E e)
将指定元素添加到此列表的末尾（最后一个元素）。

boolean

offerFirst(E e)
在此列表的开头插入指定的元素。

boolean

offerLast(E e)
在此列表末尾插入指定的元素。

peek()
获取但不移除此列表的头（第一个元素）。

peekFirst()
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

peekLast()
获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

poll()
获取并移除此列表的头（第一个元素）

pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

pollLast()
获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

pop()
从此列表所表示的堆栈处弹出一个元素。

void

push(E e)
将元素推入此列表所表示的堆栈。

remove()
获取并移除此列表的头（第一个元素）。

remove(int index)
移除此列表中指定位置处的元素。

boolean

remove(Object o)
从此列表中移除首次出现的指定元素（如果存在）。

removeFirst()
移除并返回此列表的第一个元素。

boolean

removeFirstOccurrence(Object o)
从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。

removeLast()
移除并返回此列表的最后一个元素。

boolean

removeLastOccurrence(Object o)
从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。

set(int index, E element)
将此列表中指定位置的元素替换为指定的元素。

int

size()
返回此列表的元素数。

Object[]

toArray()
返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。

<T> T[]

toArray(T[] a)
返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。

LinkedList使用示例

import java.util.Iterator;

import java.util.LinkedList;

publicclassLinkedListDemo {

publicstaticvoid main(String[] srgs){

LinkedList<Integer> linkedList = newLinkedList<>();

/* 基本操作 ************************/

linkedList.addFirst(0); // 添加元素到列表开头

linkedList.add(1); // 在列表结尾添加元素

linkedList.add(2,2); // 在指定位置添加元素

linkedList.addLast(3); // 添加元素到列表结尾

System.out.println("LinkedList: " + linkedList);

System.out.println("getFirst():" + linkedList.getFirst()); // 返回此列表的第一个元素

System.out.println("getLast():" + linkedList.getLast()); // 返回此列表的最后一个元素

System.out.println("removeFirst(): " + linkedList.removeFirst()); // 移除并返回此列表的第一个元素

System.out.println("removeLast(): " + linkedList.removeLast()); // 移除并返回此列表的最后一个元素

System.out.println("After remove:" + linkedList);

System.out.println("contains(1) is :" + linkedList.contains(1)); // 判断此列表包含指定元素，如果是，则返回true

System.out.println("size is : " + linkedList.size()); // 返回此列表的元素个数，/位置访问操作/

System.out.println("----------------------");

linkedList.set(1, 3);

// 将此列表中指定位置的元素替换为指定的元素

System.out.println("After set(1, 3):" + linkedList);

System.out.println("get(1):" + linkedList.get(1)); // 返回此列表中指定位置处的元素

/*Search操作 ************************/

System.out.println("---------------------");

linkedList.add(3);

System.out.println("indexOf(3):" + linkedList.indexOf(3)); // 返回此列表中首次出现的指定元素的索引

System.out.println("lastIndexOf(3):" + linkedList.lastIndexOf(3));// 返回此列表中最后出现的指定元素的索引

/*Queue操作 */

System.out.println("--------------------");

System.out.println("peek():" + linkedList.peek()); // 获取但不移除此列表的头

System.out.println("element():" + linkedList.element()); // 获取但不移除此列表的头

linkedList.poll(); // 获取并移除此列表的头

System.out.println("After poll():" + linkedList);

linkedList.remove();

System.out.println("Afterremove():" + linkedList); // 获取并移除此列表的头

linkedList.offer(4);

System.out.println("Afteroffer(4):" + linkedList); // 将指定元素添加到此列表的末尾

/* Deque操作 */

System.out.println("---------------------------");

linkedList.offerFirst(2); // 在此列表的开头插入指定的元素

System.out.println("After offerFirst(2):" + linkedList);

linkedList.offerLast(5); // 在此列表末尾插入指定的元素

System.out.println("After offerLast(5):" + linkedList);

System.out.println("peekFirst():" + linkedList.peekFirst()); // 获取但不移除此列表的第一个元素

System.out.println("peekLast():" + linkedList.peekLast()); // 获取但不移除此列表的第一个元素

linkedList.pollFirst(); // 获取并移除此列表的第一个元素

System.out.println("After pollFirst():" + linkedList);

linkedList.pollLast(); // 获取并移除此列表的最后一个元素

System.out.println("After pollLast():" + linkedList);

linkedList.push(2); // 将元素推入此列表所表示的堆栈（插入到列表的头）

System.out.println("After push(2):" + linkedList);

linkedList.pop(); // 从此列表所表示的堆栈处弹出一个元素（获取并移除列表第一个元素）

System.out.println("After pop():" + linkedList);

linkedList.add(3);

linkedList.removeFirstOccurrence(3); // 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表）

System.out.println("After removeFirstOccurrence(3):" + linkedList);

linkedList.removeLastOccurrence(3); // 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表）

System.out.println("After removeFirstOccurrence(3):" + linkedList);

/* 遍历操作 */

System.out.println("-------------------------");

linkedList.clear();

for(int i = 0; i < 100000;i++){

linkedList.add(i);

}

// 迭代器遍历

long start =System.currentTimeMillis();

Iterator<Integer> iterator =linkedList.iterator();

while(iterator.hasNext()){

iterator.next();

}

long end =System.currentTimeMillis();

System.out.println("Iterator：" + (end - start) +" ms");

// 顺序遍历(随机遍历)

start = System.currentTimeMillis();

for(int i = 0; i < linkedList.size();i++){

linkedList.get(i);

}

end = System.currentTimeMillis();

System.out.println("for：" +(end - start) +"ms");

// 另一种for循环遍历

start = System.currentTimeMillis();

for(Integer i : linkedList);

end = System.currentTimeMillis();

System.out.println("for2：" +(end - start) +"ms");

// 通过pollFirst()或pollLast()来遍历LinkedList

LinkedList<Integer> temp1 = newLinkedList<>();

temp1.addAll(linkedList);

start = System.currentTimeMillis();

while(temp1.size() != 0){

temp1.pollFirst();

}

end = System.currentTimeMillis();

System.out.println("pollFirst()或pollLast()：" + (end - start) +" ms");

// 通过removeFirst()或removeLast()来遍历LinkedList

LinkedList<Integer> temp2 = newLinkedList<>();

temp2.addAll(linkedList);

start = System.currentTimeMillis();

while(temp2.size() != 0){

temp2.removeFirst();

}

end = System.currentTimeMillis();

System.out.println("removeFirst()或removeLast()：" + (end - start) +" ms");

}

/**Output

LinkedList: [0, 1, 2, 3]

getFirst(): 0

getLast(): 3

removeFirst(): 0

removeLast(): 3

After remove:[1, 2]

contains(1) is :true

size is : 2

-----------------------------------------

After set(1, 3):[1, 3]

get(1): 3

-----------------------------------------

indexOf(3): 1

lastIndexOf(3): 2

-----------------------------------------

peek(): 1

element(): 1

After poll():[3, 3]

After remove():[3]

After offer(4):[3, 4]

-----------------------------------------

After offerFirst(2):[2, 3, 4]

After offerLast(5):[2, 3, 4, 5]

peekFirst(): 2

peekLast(): 5

After pollFirst():[3, 4, 5]

After pollLast():[3, 4]

After push(2):[2, 3, 4]

After pop():[3, 4]

After removeFirstOccurrence(3):[4, 3]

After removeFirstOccurrence(3):[4]

-----------------------------------------

Iterator：17 ms

for：8419 ms

for2：12 ms

pollFirst()或pollLast()：12 ms

removeFirst()或removeLast()：10 ms

*/

1、使用链表实现栈效果

1. import java.util.LinkedList;

2. public class MainClass {

3. public static void main(String[] args) {

4. StackL stack = new StackL();

5. for (int i = 0; i < 10; i++)

6. stack.push(i);

7. System.out.println(stack.top());

8. System.out.println(stack.top());

9. System.out.println(stack.pop());

10. System.out.println(stack.pop());

11. System.out.println(stack.pop());

12. }

13. }

14. class StackL {

15. private LinkedList list = new LinkedList();

16. public void push(Object v) {

17. list.addFirst(v);

18. }

19. public Object top() {

20. return list.getFirst();

21. }

22. public Object pop() {

23. return list.removeFirst();

24. }

25. }

实例2

1. import java.util.Collections;

2. import java.util.LinkedList;

3. public class Main {

4. public static void main(String[] argv) throws Exception {

5. LinkedList stack = new LinkedList();

6. Object object = "";

7. stack.addFirst(object);

8. Object o = stack.getFirst();

9. stack = (LinkedList) Collections.synchronizedList(stack);

10. }

11. }

2、使用链表来实现队列效果

1. import java.util.LinkedList;

2. public class MainClass {

3. public static void main(String[] args) {

4. Queue queue = new Queue();

5. for (int i = 0; i < 10; i++)

6. queue.put(Integer.toString(i));

7. while (!queue.isEmpty())

8. System.out.println(queue.get());

9. }

10. }

11. class Queue {

12. private LinkedList list = new LinkedList();

13. public void put(Object v) {

14. list.addFirst(v);

15. }

16. public Object get() {

17. return list.removeLast();

18. }

19. public boolean isEmpty() {

20. return list.isEmpty();

21. }

22. }

实例2

1. import java.util.LinkedList;

2. public class Main {

3. public static void main(String[] argv) throws Exception {

4. LinkedList queue = new LinkedList();

5. Object object = "";

6. // Add to end of queue

7. queue.add(object);

8. // Get head of queue

9. Object o = queue.removeFirst();

10. }

11. }

3、将LinkedList转换成ArrayList

1. ArrayList<String> arrayList = new ArrayList<String>(linkedList);

2. for (String s : arrayList) {

3. System.out.println("s = " + s);

4. }

4、删掉所有元素：清空LinkedList
lList.clear();

5、将LinkedList转换为数组，数组长度为0

1. import java.util.LinkedList;

2. import java.util.List;

3. public class Main {

4. public static void main(String[] args) {

5. List<String> theList = new LinkedList<String>();

6. theList.add("A");

7. theList.add("B");

8. theList.add("C");

9. theList.add("D");

10. String[] my = theList.toArray(new String[0]);

11. for (int i = 0; i < my.length; i++) {

12. System.out.println(my[i]);

13. }

14. }

15. }

6、将LinkedList转换为数组，数组长度为链表长度

1. import java.util.LinkedList;

2. import java.util.List;

3. public class Main {

4. public static void main(String[] args) {

5. List<String> theList = new LinkedList<String>();

6. theList.add("A");

7. theList.add("B");

8. theList.add("C");

9. theList.add("D");

10. String[] my = theList.toArray(new String[theList.size()]);

11. for (int i = 0; i < my.length; i++) {

12. System.out.println(my[i]);

13. }

14. }

15. }

7、链表添加对象

1. import java.util.LinkedList;

2. class Address {

3. private String name;

4. private String street;

5. private String city;

6. private String state;

7. private String code;

8. Address(String n, String s, String c, String st, String cd) {

9. name = n;

10. street = s;

11. city = c;

12. state = st;

13. code = cd;

14. }

15. public String toString() {

16. return name + " " + street + " " + city + " " + state + " " + code;

17. }

18. }

19. class MailList {

20. public static void main(String args[]) {

21. LinkedList<Address> ml = new LinkedList<Address>();

22. ml.add(new Address("A", "11 Ave", "U", "IL", "11111"));

23. ml.add(new Address("R", "11 Lane", "M", "IL", "22222"));

24. ml.add(new Address("T", "8 St", "C", "IL", "33333"));

25. for (Address element : ml)

26. System.out.println(element + "\n");

27. }

28. }

8、确认链表是否存在特定元素

1. import java.util.LinkedList;

2. public class Main {

3. public static void main(String[] args) {

4. LinkedList<String> lList = new LinkedList<String>();

5. lList.add("1");

6. lList.add("2");

7. lList.add("3");

8. lList.add("4");

9. lList.add("5");

10. if (lList.contains("4")) {

11. System.out.println("LinkedList contains 4");

12. } else {

13. System.out.println("LinkedList does not contain 4");

14. }

15. }

16. }

9、根据链表元素生成对象数组

1. Object[] objArray = lList.toArray();

2. for (Object obj: objArray) {

3. System.out.println(obj);

4. }

Vector类

方法摘要

boolean

add(E e)
将指定元素添加到此向量的末尾。

void

add(int index, E element)
在此向量的指定位置插入指定的元素。

boolean

addAll(Collection<? extends E> c)
将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。

boolean

addAll(int index, Collection<? extends E> c)
在指定位置将指定 Collection 中的所有元素插入到此向量中。

void

addElement(E obj)
将指定的组件添加到此向量的末尾，将其大小增加 1。

int

capacity()
返回此向量的当前容量。

void

clear()
从此向量中移除所有元素。

Object

clone()
返回向量的一个副本。

boolean

contains(Object o)
如果此向量包含指定的元素，则返回 true。

boolean

containsAll(Collection<?> c)
如果此向量包含指定 Collection 中的所有元素，则返回 true。

void

copyInto(Object[] anArray)
将此向量的组件复制到指定的数组中。

elementAt(int index)
返回指定索引处的组件。

Enumeration<E>

elements()
返回此向量的组件的枚举。

void

ensureCapacity(int minCapacity)
增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。

boolean

equals(Object o)
比较指定对象与此向量的相等性。

firstElement()
返回此向量的第一个组件（位于索引 0) 处的项）。

get(int index)
返回向量中指定位置的元素。

int

hashCode()
返回此向量的哈希码值。

int

indexOf(Object o)
返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。

int

indexOf(Object o, int index)
返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。

void

insertElementAt(E obj, int index)
将指定对象作为此向量中的组件插入到指定的 index 处。

boolean

isEmpty()
测试此向量是否不包含组件。

lastElement()
返回此向量的最后一个组件。

int

lastIndexOf(Object o)
返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。

int

lastIndexOf(Object o, int index)
返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。

remove(int index)
移除此向量中指定位置的元素。

boolean

remove(Object o)
移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。

boolean

removeAll(Collection<?> c)
从此向量中移除包含在指定 Collection 中的所有元素。

void

removeAllElements()
从此向量中移除全部组件，并将其大小设置为零。

boolean

removeElement(Object obj)
从此向量中移除变量的第一个（索引最小的）匹配项。

void

removeElementAt(int index)
删除指定索引处的组件。

protected void

removeRange(int fromIndex, int toIndex)
从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。

boolean

retainAll(Collection<?> c)
在此向量中仅保留包含在指定 Collection 中的元素。

set(int index, E element)
用指定的元素替换此向量中指定位置处的元素。

void

setElementAt(E obj, int index)
将此向量指定 index 处的组件设置为指定的对象。

void

setSize(int newSize)
设置此向量的大小。

int

size()
返回此向量中的组件数。

List<E>

subList(int fromIndex, int toIndex)
返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。

Object[]

toArray()
返回一个数组，包含此向量中以恰当顺序存放的所有元素。

<T> T[]

toArray(T[] a)
返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。

String

toString()
返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。

void

trimToSize()
对此向量的容量进行微调，使其等于向量的当前大小。

从接口 java.util.List继承的方法

iterator, listIterator, listIterator

使用示例

publicclassVectorReview {

publicstaticvoidmain(String[] args) {

Vector<String> vector=newVector<>();

vector.addElement("e1");

vector.addElement("e2");

vector.addElement("e3");

vector.addElement("e4");

vector.addElement("e5");

vector.add(3, "e6"); //在指定位置添加元素，非覆盖

printList(vector);

// copyInto将内容拷贝到一个数组中

String[] anArray=newString[vector.size()]; // 注意数组长度不要小于vector的size

vector.copyInto(anArray);

for (String string :anArray) {

System.out.print(string+" ");

}

System.out.println("\n--------");

// 返回指定位置的元素

String elementAt = vector.elementAt(2);

System.out.println(elementAt);

System.out.println(vector.firstElement());// 返回此向量的第一个组件，索引0的元素

System.out.println(vector.lastElement());//返回此向量的最后一个组件

// 删除元素

//vector.removeAllElements(); // 从此向量中移除全部组件，并将其大小设置为零。

System.out.println(vector.removeElement("e5")); // 从此向量中移除变量的第一个（索引最小的）匹配项。

vector.removeElementAt(2); // 删除指定索引处的组件。

vector.setElementAt("yyy", 3); // 将此向量指定index 处的组件设置为指定的对象。注意index要小于vector的size

printList(vector);

// 返回此向量的组件的枚举

Enumeration<String> elements = vector.elements();

while(elements.hasMoreElements()){

System.out.print(elements.nextElement()+" ");

}

System.out.println("\n--------");

}

publicstaticvoidprintList(List<String> list) {

for (String string : list) {

System.out.print(string+" ");

}

System.out.println("\n-----------------");

}

Stack类的介绍以及使用

Java 中，使用 java.util.Stack 类的构造方法创建对象。

public class Stack extendsvector

构造方法： public Stack() 创建一个空 Stack。

方法：

1. public push （item ）

把项压入栈顶。其作用与addElement (item ) 相同。参数 item 压入栈顶的项。返回： item 参数；

2.public pop () 移除栈顶对象，并作为函数的值返回该对象。

返回：栈顶对象（Vector 对象的中的最后一项）。

抛出异常：EmptyStackException 如果堆栈式空的。。。

3.public peek() 查看栈顶对象而不移除它。。

返回：栈顶对象（Vector 对象的中的最后一项）。

抛出异常：EmptyStackException 如果堆栈式空的。。。

4public boolean empty （测试堆栈是否为空。）

当且仅当堆栈中不含任何项时返回 true，否则返回 false.

5 publicint search (object o)

返回对象在堆栈中位置，以 1 为基数，如果对象ｏ是栈中的一项，该方法返回距离　栈顶最近的出现位置到栈顶的距离；　栈中最上端项的距离为　１　。　使用equals 方法比较 o 与堆栈中的项。。。

使用示例

import java.util.Stack;

public classDemo6 {

/**

*yy 测试java中自带的stack类

* boolean empty() 测试堆栈是否为空。

* E peek() 查看栈顶对象而不移除它。 E

* pop() 移除栈顶对象并作为此函数的值返回该对象。

* E push(E item) 把项压入栈顶。

* int search(Object o) 返回对象在栈中的位置，以 1 为基数

public static void main(String[] args) {

Stack<String> stack=new Stack<String>();

stack.push("a");

stack.push("b");

stack.push("c");

System.out.println(stack.peek());//c

System.out.println(stack.search("a"));//3

while(!stack.isEmpty()){

String v=stack.pop();

System.out.print(v+" ");

}//c b a

System.out.println();

System.out.println(stack.search("a"));//-1

}

Queue（队列模型）

`boolean`	add`(`E `e)` 将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 `true`，如果当前没有可用的空间，则抛出 `IllegalStateException`。
E	element`()` 获取，但是不移除此队列的头。
`boolean`	offer`(`E `e)` 将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 `add(E)`，后者可能无法插入元素，而只是抛出一个异常。
E	peek`()` 获取但不移除此队列的头；如果此队列为空，则返回 `null`。
E	poll`()` 获取并移除此队列的头，如果此队列为空，则返回 `null`。
E	remove`()` 获取并移除此队列的头。

使用示例

import java.util.LinkedList;

import java.util.Queue;

public classDemo6 {

publicstaticvoidmain(String [] args){

Queue<String> queue = newLinkedList<String>();

//追加元素

queue.offer("one");

queue.offer("two");

queue.offer("three");

queue.offer("four");

System.out.println(queue);

//从队首取出元素并删除

String poll = queue.poll();

System.out.println(poll);

System.out.println(queue);

//从队首取出元素但是不删除

String peek = queue.peek();

System.out.println(peek);

System.out.println(queue);

//遍历队列，这里要注意，每次取完元素后都会删除，整个

//队列会变短，所以只需要判断队列的大小即可

while(queue.size() > 0) {

System.out.println(queue.poll());

}

结果

Dueue（双向队列模型）

双向队列(Deque)扩展了 Queue 接口。在将双端队列用作队列时，将得到 FIFO（先进先出）行为。将元素添加到双端队列的末尾，从双端队列的开头移除元素。从 Queue 接口继承的方法完全等效于 Deque 方法，如下表所示：

Queue 方法	等效 Deque 方法
add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

双端队列也可用作 LIFO（后进先出）堆栈。应优先使用此接口而不是遗留 Stack 类。在将双端队列用作堆栈时，元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法完全等效于 Deque 方法，如下表所示：

堆栈方法	等效 Deque 方法
push(e)	addFirst(e)
pop()	removeFirst()
peek()	peekFirst()

注意，在将双端队列用作队列或堆栈时，peek 方法同样正常工作；无论哪种情况下，都从双端队列的开头抽取元素。

方法摘要
`boolean`	add`(`E `e)` 将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 `true`，如果当前没有可用空间，则抛出 `IllegalStateException`。
`void`	addFirst`(`E `e)` 将指定元素插入此双端队列的开头（如果可以直接这样做而不违反容量限制）。
`void`	addLast`(`E `e)` 将指定元素插入此双端队列的末尾（如果可以直接这样做而不违反容量限制）。
`boolean`	contains`(`Object `o)` 如果此双端队列包含指定元素，则返回 `true`。
Iterator`<`E`>`	descendingIterator`()` 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E	element`()` 获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
E	getFirst`()` 获取，但不移除此双端队列的第一个元素。
E	getLast`()` 获取，但不移除此双端队列的最后一个元素。
Iterator`<`E`>`	iterator`()` 返回以恰当顺序在此双端队列的元素上进行迭代的迭代器。
`boolean`	offer`(`E `e)` 将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 `true`，如果当前没有可用的空间，则返回 `false`。
`boolean`	offerFirst`(`E `e)` 在不违反容量限制的情况下，将指定的元素插入此双端队列的开头。
`boolean`	offerLast`(`E `e)` 在不违反容量限制的情况下，将指定的元素插入此双端队列的末尾。
E	peek`()` 获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 `null`。
E	peekFirst`()` 获取，但不移除此双端队列的第一个元素；如果此双端队列为空，则返回 `null`。
E	peekLast`()` 获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回 `null`。
E	poll`()` 获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 `null`。
E	pollFirst`()` 获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 `null`。
E	pollLast`()` 获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 `null`。
E	pop`()` 从此双端队列所表示的堆栈中弹出一个元素。
`void`	push`(`E `e)` 将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 `true`，如果当前没有可用空间，则抛出 `IllegalStateException`。
E	remove`()` 获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
`boolean`	remove`(`Object `o)` 从此双端队列中移除第一次出现的指定元素。
E	removeFirst`()` 获取并移除此双端队列第一个元素。
`boolean`	removeFirstOccurrence`(`Object `o)` 从此双端队列移除第一次出现的指定元素。
E	removeLast`()` 获取并移除此双端队列的最后一个元素。
`boolean`	removeLastOccurrence`(`Object `o)` 从此双端队列移除最后一次出现的指定元素。
`int`	size`()` 返回此双端队列的元素数。

import java.util.Deque;

import java.util.LinkedList;

public classDemo6 {

publicstaticvoidmain(String[] args){

Deque<String> deque = newLinkedList<String>();

deque.push("a");

deque.push("b");

deque.push("c");

System.out.println(deque);

//获取栈首元素后，元素不会出栈

String str = deque.peek();

System.out.println(str);

System.out.println(deque);

while(deque.size() > 0) {

//获取栈首元素后，元素将会出栈

System.out.println(deque.pop());

}

System.out.println(deque);

}

结果：

java.util.Iterator类

方法摘要
`boolean`	hasNext`()` 如果仍有元素可以迭代，则返回 `true`。
E	next`()` 返回迭代的下一个元素。
`void`	remove`()` 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

迭代器应用：

list l = new ArrayList();

l.add("aa");

l.add("bb");

l.add("cc");

for (Iterator iter = l.iterator();iter.hasNext();) {

String str = (String)iter.next();

System.out.println(str);

}

/*迭代器用于while循环

Iterator iter = l.iterator();

while(iter.hasNext()){

String str = (String) iter.next();

System.out.println(str);

}

*/

java.util.ListIterator类

方法摘要
`void`	add`(`E `e)` 将指定的元素插入列表（可选操作）。
`boolean`	hasNext`()` 以正向遍历列表时，如果列表迭代器有多个元素，则返回 `true`（换句话说，如果 `next` 返回一个元素而不是抛出异常，则返回 `true`）。
`boolean`	hasPrevious`()` 如果以逆向遍历列表，列表迭代器有多个元素，则返回 `true`。
E	next`()` 返回列表中的下一个元素。
`int`	nextIndex`()` 返回对 `next` 的后续调用所返回元素的索引。
E	previous`()` 返回列表中的前一个元素。
`int`	previousIndex`()` 返回对 `previous` 的后续调用所返回元素的索引。
`void`	remove`()` 从列表中移除由 `next` 或 `previous` 返回的最后一个元素（可选操作）。
`void`	set`(`E `e)` 用指定元素替换 `next` 或 `previous` 返回的最后一个元素（可选操作）。

实例：

import java.util.ArrayList;

import java.util.List;

import java.util.ListIterator;

public classDemo6 {

public staticvoidmain(String[] args){

List<String> lists = newArrayList<String>();

lists.add("1A");

lists.add("2B");

lists.add("3C");

lists.add("4D");

lists.add("5F");

lists.add("6F");

lists.add("7G");

ListIterator<String> iterator = lists.listIterator();

System.out.println("-----------");

//向后遍历

while(iterator.hasNext()){

System.out.print(iterator.next()+" ");

}

System.out.println();

System.out.println("-----------");

//此时游标已经指向迭代器的尾部，可以向前遍历

while(iterator.hasPrevious()){

System.out.print(iterator.previous()+" ");

}

System.out.println();

System.out.println("-----------");

//从指定位置向前遍历

iterator= lists.listIterator(2);

while(iterator.hasPrevious()){

System.out.print(iterator.previous()+" ");

}

System.out.println();

System.out.println("-----------");

iterator= lists.listIterator();

//替换元素

while(iterator.hasNext()){

String str= iterator.next();

iterator.set("H:"+str);

}

while(iterator.hasPrevious()){

System.out.print(iterator.previous()+" ");

}

Set泛型接口

java.util.Set类

方法摘要

boolean

add(E e)
如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。

boolean

addAll(Collection<? extends E> c)
如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。

void

clear()
移除此 set 中的所有元素（可选操作）。

boolean

contains(Object o)
如果 set 包含指定的元素，则返回 true。

boolean

containsAll(Collection<?> c)
如果此 set 包含指定 collection 的所有元素，则返回 true。

boolean

equals(Object o)
比较指定对象与此 set 的相等性。

int

hashCode()
返回 set 的哈希码值。

boolean

isEmpty()
如果 set 不包含元素，则返回 true。

Iterator<E>

iterator()
返回在此 set 中的元素上进行迭代的迭代器。

boolean

remove(Object o)
如果 set 中存在指定的元素，则将其移除（可选操作）。

boolean

removeAll(Collection<?> c)
移除 set 中那些包含在指定 collection 中的元素（可选操作）。

boolean

retainAll(Collection<?> c)
仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。

int

size()
返回 set 中的元素数（其容量）。

Object[]

toArray()
返回一个包含 set 中所有元素的数组。

<T> T[]

toArray(T[] a)
返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

java.util.HashSet类

方法摘要
`boolean`	add`(`E `e)` 如果此 set 中尚未包含指定元素，则添加指定元素。
`void`	clear`()` 从此 set 中移除所有元素。
Object	clone`()` 返回此 `HashSet` 实例的浅表副本：并没有复制这些元素本身。
`boolean`	contains`(`Object `o)` 如果此 set 包含指定元素，则返回 `true`。
`boolean`	isEmpty`()` 如果此 set 不包含任何元素，则返回 `true`。
Iterator`<`E`>`	iterator`()` 返回对此 set 中元素进行迭代的迭代器。
`boolean`	remove`(`Object `o)` 如果指定元素存在于此 set 中，则将其移除。
`int`	size`()` 返回此 set 中的元素的数量（set 的容量）。

从接口 java.util.Set继承的方法

addAll, containsAll, equals, hashCode, removeAll, retainAll, toArray, toArray

实例

public static void hashSet1(){
HashSet<String> hashSet = new HashSet<String>();
hashSet.add("java001");
hashSet.add("java01");
hashSet.add("java011");
hashSet.add("java002");
hashSet.add("java004");
//使用常用迭代器获取输出内容
Iterator<String> iterator = hashSet.iterator();
while (iterator.hasNext()) {
String next = iterator.next();
System.out.println(next);
}
}

java.util.TreeSet 类

方法摘要
`boolean`	add`(`E `e)` 将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
`boolean`	addAll`(`Collection`<? extends` E`> c)` 将指定 collection 中的所有元素添加到此 set 中。
E	ceiling`(`E `e)` 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 `null`。
`boolean`	contains`(`Object `o)` 如果此 set 包含指定的元素，则返回 `true`。
Iterator`<`E`>`	descendingIterator`()` 返回在此 set 元素上按降序进行迭代的迭代器。
E	first`()` 返回此 set 中当前第一个（最低）元素。
E	floor`(`E `e)` 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 `null`。
E	higher`(`E `e)` 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 `null`。
`boolean`	isEmpty`()` 如果此 set 不包含任何元素，则返回 `true`。
Iterator`<`E`>`	iterator`()` 返回在此 set 中的元素上按升序进行迭代的迭代器。
E	last`()` 返回此 set 中当前最后一个（最高）元素。
E	lower`(`E `e)` 返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 `null`。
E	pollFirst`()` 获取并移除第一个（最低）元素；如果此 set 为空，则返回 `null`。
E	pollLast`()` 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 `null`。
`boolean`	remove`(`Object `o)` 将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
`int`	size`()` 返回 set 中的元素数（set 的容量）。

treeSet添加自定义元素:
treeSet要注意的事项：
1. 往TreeSet添加元素的时候，如果元素本身具备了自然顺序的特性，那么就按照元素自然顺序的特性进行排序存储。
2. 往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，那么该元素所属的类必须要实现Comparable接口，把元素的比较规则定义在compareTo(T o)方法上。
3. 如果比较元素的时候，compareTo方法返回的是0，那么该元素就被视为重复元素，不允许添加.(注意：TreeSet与HashCode、equals方法是没有任何关系。)
4. 往TreeSet添加元素的时候, 如果元素本身没有具备自然顺序的特性，而元素所属的类也没有实现Comparable接口，那么必须要在创建TreeSet的时候传入一个比较器。
5. 往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，而元素所属的类已经实现了Comparable接口，在创建TreeSet对象的时候也传入了比较器那么是以比较器的比较规则优先使用。
如何自定义定义比较器：自定义一个类实现Comparator接口即可，把元素与元素之间的比较规则定义在compare方法内即可。
自定义比较器的格式：
class 类名 implements Comparator{
}
推荐使用：使用比较器(Comparator)。
TreeSet是可以对字符串进行排序的，因为字符串已经实现了Comparable接口。
字符串的比较规则：
情况一：对应位置有不同的字符出现，就比较的就是对应位置不同的字符。
情况二：对应位置上的字符都一样，比较的就是字符串的长度。

1. import java.util.Comparator;

2. import java.util.TreeSet;

3. class Emp implements Comparable<Emp>{

4. int id;

5. String name;

6. int salary;

7. public Emp(int id, String name, int salary) {

8. super();

9. this.id = id;

10. this.name = name;

11. this.salary = salary;

12. }

13. @Override

14. public String toString() {

15. return "{ 编号："+ this.id+" 姓名："+ this.name+" 薪水："+ this.salary+"}";

16. }

17. //@Override //元素与元素之间的比较规则。

18. // 负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。

19. public int compareTo(Emp o) {

20. // System.out.println(this.name+"compare"+ e.name);

21. return this.salary- o.salary;

22. }

23.}

24.

25. //自定义一个比较器

26. class MyComparator implements Comparator<Emp>{

27.

28. @Override

29. public int compare(Emp o1, Emp o2) {

30. return o1.id-o2.id;

31. }

32. //根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

33. /*@Override

34. public int compare(Object o1, Object o2) {

35. Emp e1 = (Emp) o1;

36. Emp e2 = (Emp) o2;

37. return e1.id - e2.id;

38. }*/

39. }

40. public class Demo6 {

41. public static void main(String[] args) {

42. //创建一个比较器对象

43. MyComparator comparator = new MyComparator();

44. //创建TreeSet的时候传入比较器

45. TreeSet tree = new TreeSet(comparator);

46. tree.add(new Emp(110, "老陆", 100));

47. tree.add(new Emp(113, "老钟", 200));

48. tree.add(new Emp(220, "老汤", 300));

49. tree.add(new Emp(120, "老蔡", 500));

50. System.out.println("集合的元素："+tree);

51.

52. }

53. }

运行结果：
集合的元素：[{ 编号：110 姓名：老陆薪水：100}, { 编号：113 姓名：老钟薪水：200}, { 编号：120 姓名：老蔡薪水：500}, { 编号：220 姓名：老汤薪水：300}]

需求：将字符串中的数值进行排序。
例如String str="8 10 15 5 2 7"; ----> "2 5 7 8 10 15"
import java.util.Iterator;

1. import java.util.TreeSet;

2. /*

3. 需求：将字符串中的数值进行排序。

4. 例如String str="8 10 15 5 2 7"; ----> "2 5 7 8 10 15"

5. */

6. public class Demo8 {

7. public static void main(String[] args) {

8. String str="8 10 15 5 2 7";

9. String[] datas = str.split(" ");

10. TreeSet tree = new TreeSet();

11. for(int i = 0 ; i<datas.length ; i++){

12. tree.add(Integer.parseInt( datas[i])); // 字符串转int类型数据是需要使用Integer.parseInt()

13. }

14. //遍历treeSet的元素拼接成对应的字符串

15. Iterator it = tree.iterator();

16. while(it.hasNext()){

17. System.out.print(it.next()+" ");

18. }

19. }

20. }

运行结果：
2 5 7 8 10 15

4.22 LinkedHashSet使用示例

publicclass LinkedHashSetReceive {

    publicstaticvoidmain(String[] args) {

     LinkedHashSet<String> linkedHashSet=new LinkedHashSet<String>();

        linkedHashSet.add("a");

        linkedHashSet.add("d");

        linkedHashSet.add("b");

        linkedHashSet.add("f");

        linkedHashSet.add("c");

        for (String string : linkedHashSet) {

            System.out.println(string);

接口(Map<K,V>)

java.util.Map

方法摘要
`void`	clear`()` 从此映射中移除所有映射关系（可选操作）。
`boolean`	containsKey`(`Object `key)` 如果此映射包含指定键的映射关系，则返回 `true`。
`boolean`	containsValue`(`Object `value)` 如果此映射将一个或多个键映射到指定值，则返回 `true`。
Set`<`Map.Entry`<`K`,`V`>>`	entrySet`()` 返回此映射中包含的映射关系的 `Set` 视图。
`boolean`	equals`(`Object `o)` 比较指定的对象与此映射是否相等。
V	get`(`Object `key)` 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 `null`。
`int`	hashCode`()` 返回此映射的哈希码值。
`boolean`	isEmpty`()` 如果此映射未包含键-值映射关系，则返回 `true`。
Set`<`K`>`	keySet`()` 返回此映射中包含的键的 `Set` 视图。
V	put`(`K `key,` V `value)` 将指定的值与此映射中的指定键关联（可选操作）。
`void`	putAll`(`Map`<? extends` K`,? extends` V`> m)` 从指定映射中将所有映射关系复制到此映射中（可选操作）。
V	remove`(`Object `key)` 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
`int`	size`()` 返回此映射中的键-值映射关系数。
Collection`<`V`>`	values`()` 返回此映射中包含的值的 `Collection` 视图。

java.util.HashMap

方法摘要
`void`	clear`()` 从此映射中移除所有映射关系。
Object	clone`()` 返回此 `HashMap` 实例的浅表副本：并不复制键和值本身。
`boolean`	containsKey`(`Object `key)` 如果此映射包含对于指定键的映射关系，则返回 `true`。
`boolean`	containsValue`(`Object `value)` 如果此映射将一个或多个键映射到指定值，则返回 `true`。
Set`<`Map.Entry`<`K`,`V`>>`	entrySet`()` 返回此映射所包含的映射关系的 `Set` 视图。
V	get`(`Object `key)` 返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 `null`。
`boolean`	isEmpty`()` 如果此映射不包含键-值映射关系，则返回 `true`。
Set`<`K`>`	keySet`()` 返回此映射中所包含的键的 `Set` 视图。
V	put`(`K `key,` V `value)` 在此映射中关联指定值与指定键。
`void`	putAll`(`Map`<? extends` K`,? extends` V`> m)` 将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。
V	remove`(`Object `key)` 从此映射中移除指定键的映射关系（如果存在）。
`int`	size`()` 返回此映射中的键-值映射关系数。
Collection`<`V`>`	values`()` 返回此映射所包含的值的 `Collection` 视图。

实例

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

public classMain {

public static void main(String[] args) {

Map<String,Student> stu= newHashMap<String, Student>();

// 添加元素

stu.put("0001", new Student("sunming1"));

stu.put("0002", new Student("sunming2"));

stu.put("0003", new Student("sunmnig3"));

System.out.println(stu);

System.out.println("-------------------------");

// 删除元素

stu.remove("0001");

System.out.println(stu);

System.out.println("-------------------------");

// 更新元素

stu.put("0002", new Student("sunmingUpdate"));

System.out.println(stu);

System.out.println("-------------------------");

// 查询元素

System.out.println(stu.get("0003"));

System.out.println("-------------------------");

// 获取所有的key和value

for (Map.Entry<String,Student> entry: stu.entrySet()){

System.out.println("key = "+ entry.getKey()+ ", value = " + entry.getValue());

}

System.out.println("-------------------------");

// 获取所有的key

Set<String>keys= stu.keySet();

for (String key : keys) {

System.out.println(key);

}

System.out.println("-------------------------");

// 获取所有的value

Collection<Student>values= stu.values();

for (Student value : values) {

System.out.println(value);

}

/**

* Created by SunMing on 2016/9/18.

public classStudent {

private String id;

private String name;

public Student(String strName) {

name = strName;

id = "00";

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String toString() {

return id + " " + name + ", ";

}

java.util.TreeMap类

方法摘要
`void`	clear`()` 从此映射中移除所有映射关系。
Object	clone`()` 返回此 `TreeMap` 实例的浅表副本。
Comparator`<? super` K`>`	comparator`()` 返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 `null`。
`boolean`	containsKey`(`Object `key)` 如果此映射包含指定键的映射关系，则返回 `true`。
`boolean`	containsValue`(`Object `value)` 如果此映射为指定值映射一个或多个键，则返回 `true`。
NavigableSet`<`K`>`	descendingKeySet`()` 返回此映射中所包含键的逆序 `NavigableSet` 视图。
NavigableMap`<`K`,`V`>`	descendingMap`()` 返回此映射中所包含映射关系的逆序视图。
Set`<`Map.Entry`<`K`,`V`>>`	entrySet`()` 返回此映射中包含的映射关系的 `Set` 视图。
Map.Entry`<`K`,`V`>`	firstEntry`()` 返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 `null`。
K	firstKey`()` 返回此映射中当前第一个（最低）键。
Map.Entry`<`K`,`V`>`	floorEntry`(`K `key)` 返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 `null`。
K	floorKey`(`K `key)` 返回小于等于给定键的最大键；如果不存在这样的键，则返回 `null`。
V	get`(`Object `key)` 返回指定键所映射的值，如果对于该键而言，此映射不包含任何映射关系，则返回 `null`。
Map.Entry`<`K`,`V`>`	higherEntry`(`K `key)` 返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 `null`。
K	higherKey`(`K `key)` 返回严格大于给定键的最小键；如果不存在这样的键，则返回 `null`。
Set`<`K`>`	keySet`()` 返回此映射包含的键的 `Set` 视图。
K	lastKey`()` 返回映射中当前最后一个（最高）键。
K	lowerKey`(`K `key)` 返回严格小于给定键的最大键；如果不存在这样的键，则返回 `null`。
V	put`(`K `key,` V `value)` 将指定值与此映射中的指定键进行关联。
`void`	putAll`(`Map`<? extends` K`,? extends` V`> map)` 将指定映射中的所有映射关系复制到此映射中。
V	remove`(`Object `key)` 如果此 TreeMap 中存在该键的映射关系，则将其删除。
`int`	size`()` 返回此映射中的键-值映射关系数。
Collection`<`V`>`	values`()` 返回此映射包含的值的 `Collection` 视图

TreeMap的本质是R-B Tree(红黑树)，它包含几个重要的成员变量： root, size, comparator。
　　root 是红黑数的根节点。它是Entry类型，Entry是红黑数的节点，它包含了红黑数的6个基本组成成分：key(键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜色)。Entry节点根据key进行排序，Entry节点包含的内容为value。
　　红黑数排序时，根据Entry中的key进行排序；Entry中的key比较大小是根据比较器comparator来进行判断的。
　　size是红黑数中节点的个数。

关于红黑数的具体算法，请参考"红黑树(一) 原理和算法详细介绍"。

第3部分 TreeMap遍历方式

3.1 遍历TreeMap的键值对

第一步：根据entrySet()获取TreeMap的“键值对”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。

[java] view plain copy

1. // 假设map是TreeMap对象

2. // map中的key是String类型，value是Integer类型

3. Integer integ = null;

4. Iterator iter = map.entrySet().iterator();

5. while(iter.hasNext()) {

6. Map.Entry entry = (Map.Entry)iter.next();

7. // 获取key

8. key = (String)entry.getKey();

9. // 获取value

10. integ = (Integer)entry.getValue();

11. }

3.2 遍历TreeMap的键

第一步：根据keySet()获取TreeMap的“键”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。

[java] view plain copy

1. // 假设map是TreeMap对象

2. // map中的key是String类型，value是Integer类型

3. String key = null;

4. Integer integ = null;

5. Iterator iter = map.keySet().iterator();

6. while (iter.hasNext()) {

7. // 获取key

8. key = (String)iter.next();

9. // 根据key，获取value

10. integ = (Integer)map.get(key);

11. }

3.3 遍历TreeMap的值

第一步：根据value()获取TreeMap的“值”的集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。

[java] view plain copy

1. // 假设map是TreeMap对象

2. // map中的key是String类型，value是Integer类型

3. Integer value = null;

4. Collection c = map.values();

5. Iterator iter= c.iterator();

6. while (iter.hasNext()) {

7. value = (Integer)iter.next();

8. }

import java.util.Comparator;

import java.util.TreeMap;

public class Demo6 {

public static void main(String[] args) {

//1、TreeMap如不指定排序器，默认将按照key值进行升序排序，如果指定了排序器，则按照指定的排序器进行排序。

//2、具体的排序规则，可以在int compare()方法中进行指定。

//不指定排序器

TreeMap<String, String> treeMap1 = newTreeMap<String, String>();

treeMap1.put("4", "1");

treeMap1.put("2", "1");

treeMap1.put("1", "1");

treeMap1.put("3", "1");

System.out.println("treeMap1="+treeMap1);

//指定排序器

TreeMap<String, String> treeMap2 = newTreeMap<String, String>(new Comparator<String>(){

* int compare(Object o1,Object o2) 返回一个基本类型的整型，

* 返回负数表示：o1 小于o2，

* 返回0 表示：o1和o2相等，

* 返回正数表示：o1大于o2。

public int compare(String o1, String o2) {

//指定排序器按照降序排列

return o2.compareTo(o1);

}

});

treeMap2.put("2", "1");

treeMap2.put("3", "1");

treeMap2.put("1", "1");

treeMap2.put("4", "1");

System.out.println("treeMap2="+treeMap2);

}

结果：

collections在java中的常见用法

1. 工具类collections用于操作集合类，如List,Set,常用方法有：

1）排序（Sort）

使用sort方法可以根据元素的自然顺序对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的

double array[] = { 112, 111, 23, 456, 231 };

for (int i = 0; i < array.length; i++) {

list.add(new Double(array[i]));

}

Collections.sort(list);

for (int i = 0; i < array.length; i++) {

System.out.println(li.get(i));

}

//结果：112,111,23,456,231

2）混排（Shuffling）

混排算法所做的正好与 sort 相反：它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List，这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card 对象的一个 List .另外，在生成测试案例时，它也是十分有用的。

Collections.Shuffling(list)

double array[] = { 112, 111,23, 456, 231 };

for (int i = 0; i < array.length; i++) {

list.add(new Double(array[i]));

}

Collections.shuffle(list);

for (int i = 0; i < array.length; i++) {

System.out.println(li.get(i));

}

//结果：112,111,23,456,2313）

3）反转（Reverse）

使用Reverse方法可以根据元素的自然顺序对指定列表按降序进行排序。

Collections.reverse(list)

double array[] = { 112, 111, 23, 456, 231 };

for (int i = 0; i < array.length; i++) {

list.add(new Double(array[i]));

}

Collections.reverse(list);

for (int i = 0; i < array.length; i++) {

System.out.println(li.get(i));

}

//结果：231,456,23,111,112

4）替换所有的元素（Fill）

使用指定元素替换指定列表中的所有元素。

Stringstr[] = {"dd","aa","bb","cc","ee"};

for(int j=0;j<str.length;j++)

{

li.add(new String(str[j]));

}

Collections.fill(li,"aaa");

for(int i = 0;i<li.size();i++)

{

System.out.println("list[" + i + "]=" + li.get(i));

}

//结果：aaa,aaa,aaa,aaa,aaa

5）拷贝（Copy）

用两个参数，一个目标 List 和一个源 List，将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。

Collections.copy（list，li）： 后面一个参数是目标列表，前一个是源列表

double array[] = {112, 111, 23, 456, 231 };

List list = new ArrayList();

List li = new ArrayList();

for (int i= 0; i <array.length; i++){

list.add(new Double(array[i]));

}

double arr[] = {1131,333};

String str[] = {"dd","aa","bb","cc","ee"};

for(int j=0;j<array.length; j++) {

li.add(new Double(arr[j]));

}

Collections.copy(list,li);

for(int i = 0; i < list.size(); i++)

System.out.println("list["+i+"]="+list.get(i));

//结果：1131,333,23,456,231

6）返回Collections中最小元素（min）

根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.min(list)

double array[] = {112,111, 23, 456, 231 };

List<E>list = new ArrayList();

for (int i = 0; i <array.length; i++) {

list.add(new Double(array[i]));

}

Collections.min(list);

for (int i = 0;i<list.size();i++){

System.out.println("list[" + i + "]=" + list.get(i));

}

//结果：23

7）返回Collections中最大元素（max）

根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.max(list)

double array[] = {112,111, 23, 456, 231 };

Listlist = new ArrayList();

for (int i = 0; i <array.length; i++) {

list.add(new Double(array[i]));

}

Collections.max(list);

for (int i = 0; i<list.size();i++){

System.out.println("list[" + i + "]=" + list.get(i));

}

//结果：456

8）lastIndexOfSubList

返回指定源列表中最后一次出现指定目标列表的起始位置，即按从后到前的顺序返回子List在父List中的索引位置。

int count =Collections.lastIndexOfSubList(list,li);

double array[] = {112, 111,23, 456, 231 };

List list = new ArrayList();

List li = new ArrayList();

for (int i = 0; i < array.length; i++) {

list.add(newDouble(array[i]));

}

double arr[] = {111};

String str[] = {"dd","aa","bb","cc","ee"};

for(int j=0;j<arr.length;j++){

li.add(new Double(arr[j]));

}

int locations = Collections.lastIndexOfSubList (list,li);

System.out.println("==="+ locations);

//结果 3

9）IndexOfSubList

返回指定源列表中第一次出现指定目标列表的起始位置

int count =Collections.indexOfSubList(list,li);

double array[] = {112, 111, 23, 456,231 };

List list = newArrayList();

List li = new ArrayList();

for (int i = 0; i < array.length; i++) {

list.add(new Double(array[i]));

}

double arr[] = {111};

String str[] = {"dd","aa","bb","cc","ee"};

for(int j=0;j<arr.length;j++){

li.add(new Double(arr[j]));

}

int locations = Collections.indexOfSubList(list,li);

System.out.println("==="+ locations);

//结果 1

10）Rotate

根据指定的距离循环移动指定列表中的元素

Collections.rotate（list，-1）；

如果是负数，则正向移动，正数则方向移动

double array[] = {112, 111, 23, 456,231 };

List list = newArrayList();

for (int i = 0; i < array.length; i++) {

list.add(new Double(array[i]));

}

Collections.rotate(list,-1);

for (int i = 0; i<list.size();i++){

System.out.println("list[" + i + "]=" + list.get(i));

}

//结果：111,23,456,231,112

11)static int binarySearch(List list,Objectkey)

使用二分搜索查找key对象的索引值，因为使用的二分查找，所以前提是必须有序。

12)static Object max(Collection coll)

根据元素自然顺序，返回集合中的最大元素

13)static Object max(Collection coll,Comparecomp)

根据Comparator指定的顺序，返回给定集合中的最小元素

14)static Object min(Collection coll)

根据元素自然顺序，返回集合中的最大元素

15)static Object min(Collection coll,Comparecomp)

根据Comparator指定的顺序，返回给定集合中的最小元素

16）static void fill(List list,Object obj)

使用指定元素替换指定集合中的所有元素

17）static int frequency(Collection c,Object o)

返回指定元素在集合中出现在次数

18）static int indexOfSubList(List source, Listtarget)

返回子List对象在父List对象中第一次出现的位置索引；如果父List中没有出现这样的子List，则返回-1

19）static int lastIndexOfSubList(Listsource,List target)

返回子List对象在父List对象中最后一次出现的位置索引，如果父List中没有出现这样的子List，刚返回-1

20）static boolean replaceAll(List list,ObjectoldVal,Object newVal)

使用一个新值newVal替换List对象所有旧值oldVal

21）synchronizedXXX(new XXX)

Collections类为集合类们提供的同步控制方法

public class SynchronizedTest

{

public static void main(String[] args){

Collection collection = Collections.synchronizedCollections(newArrayList());

List list = Collections.synchronizedList(new ArrayList());

Set s = Collections.synchronizedSet(new HashSet());

Map s = Collections.synchronizedMap(new HashMap()):

}

22)emptyXXX()

返回一个空的、不可变的集合对象，此处的集合既可以是List，也可以是Set,还可以是Map。

23）singletonXXX()

返回一个只包含指定对象（只有一个或一项元素）的、不可变的集合对象，此处集合既可以是List,也可以是Set,还可以是Map。

24）unmodificableXXX()

指定返回集合对象的不可变视图，此处的集合既可以是Lsit,也可以是Set,Map

Java多线程：线程安全和非线程安全的集合对象

一、概念：

· 线程安全：就是当多线程访问时，采用了加锁的机制；即当一个线程访问该类的某个数据时，会对这个数据进行保护，其他线程不能对其访问，直到该线程读取完之后，其他线程才可以使用。防止出现数据不一致或者数据被污染的情况。

· 线程不安全：就是不提供数据访问时的数据保护，多个线程能够同时操作某个数据，从而出现数据不一致或者数据污染的情况。

· 对于线程不安全的问题，一般会使用synchronized关键字加锁同步控制。

· 线程安全工作原理： jvm中有一个main memory对象，每一个线程也有自己的working memory，一个线程对于一个变量variable进行操作的时候，都需要在自己的working memory里创建一个copy,操作完之后再写入main memory。
当多个线程操作同一个变量variable，就可能出现不可预知的结果。
而用synchronized的关键是建立一个监控monitor，这个monitor可以是要修改的变量，也可以是其他自己认为合适的对象(方法)，然后通过给这个monitor加锁来实现线程安全，每个线程在获得这个锁之后，要执行完加载load到working memory 到 use && 指派assign 到存储store 再到 main memory的过程。才会释放它得到的锁。这样就实现了所谓的线程安全。

二、线程安全(Thread-safe)的集合对象：

· Vector 线程安全：

· HashTable 线程安全：

· StringBuffer 线程安全：

三、非线程安全的集合对象：

· ArrayList ：

· LinkedList：

· HashMap：

· HashSet：

· TreeMap：

· TreeSet：

· StringBulider：

四、相关集合对象比较：

· Vector、ArrayList、LinkedList：
1、Vector：
Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
2、ArrayList：
a. 当操作是在一列数据的后面添加数据而不是在前面或者中间，并需要随机地访问其中的元素时，使用ArrayList性能比较好。
b. ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
3、LinkedList：
a. 当对一列数据的前面或者中间执行添加或者删除操作时，并且按照顺序访问其中的元素时，要使用LinkedList。
b. LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

Vector和ArrayList在使用上非常相似，都可以用来表示一组数量可变的对象应用的集合，并且可以随机的访问其中的元素。

ArryList和LinkedList的区别：
在处理一列数据项时，Java提供了两个类ArrayList和LinkedList，ArrayList的内部实现是基于内部数组Object[]，所以从概念上说它更像数组；然而LinkedList的内部实现是基于一组连接的记录，所以，它更像一个链表结构；所以它们在性能上有很大的差别。
由上可知，在ArrayList的前面或者中间插入数据的时候，必须将其后的所有数据相应的后移，这样要花费较多的时间；所以，当操作是在一列数据的后面添加数据而不是在前面或者中间，并需要随机地访问其中的元素时，使用ArrayList性能比较好。
然而访问链表中的某个元素的时候，就必须从链表的一端开始，沿着连接的方向一个一个元素的去查找，直到找到所需的元素为止，所以，当对一列数据的前面或者中间执行添加或者删除操作时，并且按照顺序访问其中的元素时，要使用LinkedList。
如果在实际的操作中，前面两种情况交替出现，可以考虑使用List这样的通用接口，而不用关心具体的实现，再具体的情况下，它的性能由具体的实现来保证。

· HashTable、HashMap、HashSet：
HashTable和HashMap采用的存储机制是一样的，不同的是：
1、HashMap：
a. 采用数组方式存储key-value构成的Entry对象，无容量限制；
b. 基于key hash查找Entry对象存放到数组的位置，对于hash冲突采用链表的方式去解决；
c. 在插入元素时，可能会扩大数组的容量，在扩大容量时须要重新计算hash，并复制对象到新的数组中；
d. 是非线程安全的；
e. 遍历使用的是Iterator迭代器；

2、HashTable：
a. 是线程安全的；
b. 无论是key还是value都不允许有null值的存在；在HashTable中调用Put方法时，如果key为null，直接抛出NullPointerException异常；
c. 遍历使用的是Enumeration列举；

3、HashSet：
a. 基于HashMap实现，无容量限制；
b. 是非线程安全的；
c. 不保证数据的有序；

· TreeSet、TreeMap：
TreeSet和TreeMap都是完全基于Map来实现的，并且都不支持get(index)来获取指定位置的元素，需要遍历来获取。另外，TreeSet还提供了一些排序方面的支持，例如传入Comparator实现、descendingSet以及descendingIterator等。
1、TreeSet：
a. 基于TreeMap实现的，支持排序；
b. 是非线程安全的；

2、TreeMap：
a. 典型的基于红黑树的Map实现，因此它要求一定要有key比较的方法，要么传入Comparator比较器实现，要么key对象实现Comparator接口；
b. 是非线程安全的；

· StringBuffer和StringBulider：
StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串。

1、在执行速度方面的比较：StringBuilder >StringBuffer ；
2、StringBuffer与StringBuilder，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度就快了；
3、 StringBuilder：线程非安全的；
4、StringBuffer：线程安全的；

对于String、StringBuffer和StringBulider三者使用的总结：
1.如果要操作少量的数据用 = String
2.单线程操作字符串缓冲区下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区下操作大量数据 = StringBuffer

baiyang616

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java集合类整理

在学习java的过程中，对于常用的集合类方法进行了一下整理，有的部分借鉴了一下其他人的1、Arrays用法整理本文将整理 java.util.Arrays 工具类比较常用的方法：本文介绍的方法基于JDK 1.7之上。 1） asList方法 public static List asList(T... a) { return new Array
复制链接

扫一扫