JavaSE基礎:Arrays工具類
Java工具類: Arrays
Arrays類是數組的操做類,定義在java.util包中,主要功能是實現數組元素的查找/數組內容的充填/排序等功能html
1.排序數組的sort方法
重點:對數組元素進行排序操做,默認由小到大排序.java
該方法的參數不只能夠是基礎數據類型的數組，也能夠是對象引用的數組。同時還能夠指定數組中須要排序的元素的索引範圍。算法
當對對象進行排序時，數組中的全部元素都必須實現 Comparable 接口。(就當你沒有看到,哈哈)api
即數組中的全部元素都必須是可相互比較的（也就是說，對於數組中的任何 e1 和 e2 元素而言，e1.compareTo(e2) 不得拋出 ClassCastException）數組
(1) 數字排序
排序規則:由小到大排序框架
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest01 {
public static void main(String[] args) {
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + "\t");
}
}
}
複製代碼
(2) 字符串排序
排序規則:先大寫後小寫dom
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest02 {
public static void main(String[] args) {
String[] a = {"a","A","b","B"};
Arrays.sort(a);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + "\t");
}
}
}
複製代碼
(3) 字符串嚴格排序
排序規則:嚴格按字母表順序排序，也就是忽略大小寫排序 Case-insensitive sortide
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest03 {
public static void main(String[] args) {
String[] a = {"a","C","b","D"};
Arrays.sort(a,String.CASE_INSENSITIVE_ORDER);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + "\t");
}
}
}
複製代碼
(4) 反向排序
排序規則:先小寫後大寫工具
字符串反向學習
package com.shxt.demo03;
import java.util.Arrays;
import java.util.Collections;
public class ArraysTest04 {
public static void main(String[] args) {
String[] a = {"a","A","b","B"};
Arrays.sort(a, Collections.reverseOrder());//Collections 集合類中的工具類
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + "\t");
}
}
}
複製代碼
數字排序,要使用包裝類
package com.shxt.demo03;
import java.util.Arrays;
import java.util.Collections;
public class ArraysTest05 {
public static void main(String[] args) {
//不能使用基本數據類型
Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a, Collections.reverseOrder());
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + "\t");
}
}
}
複製代碼
這個裏面咱們使用了Collections工具類,若是想本身完成規則的定義,那麼就須要使用比較器接口Comparable(簡單瞭解便可)
package com.shxt.demo03;
import java.util.Arrays;
import java.util.Comparator;
public class ArraysTest05_1 {
public static void main(String[] args) {
//不能使用基本數據類型
Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a, new IntegerComparator());
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + "\t");
}
}
}
/** * Comparator是一個接口 * 因此這裏咱們本身定義的類IntegerComparator要implents該接口 * 而不是extends Comparator * */
class IntegerComparator implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
//若是o1小於o2，咱們就返回正值，若是n1大於n2咱們就返回負值，
//這樣顛倒一下，就能夠實現反向排序了
if(o1 < o2) {
return 1;
}else if(o1 > o2) {
return -1;
}else {
return 0;
}
}
}
複製代碼
(5) 忽略大小寫反向排序
package com.shxt.demo03;
import java.util.Arrays;
import java.util.Collections;
public class ArraysTest04 {
public static void main(String[] args) {
String[] a = {"a","C","b","D"};
Arrays.sort(a, Collections.reverseOrder());
Collections.reverse(Arrays.asList(a));//先忽略吧
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + "\t");
}
}
}
複製代碼
(6) 區間排序-瞭解
Arrays.sort(int[] a, int fromIndex, int toIndex)
複製代碼
這種形式是對數組部分排序，也就是對數組a的下標從fromIndex到toIndex-1的元素排序，注意：下標爲toIndex的元素不參與排序！
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest07 {
public static void main(String[] args) {
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a, 0, 3);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + " ");
}
}
}
//運行結果爲: 7 8 9 2 3 4 1 0 6 5
複製代碼
Java初學者最多見的錯誤思想，就是試圖去寫一些方法來完成數組的排序功能，
其實，數組排序功能，在java的api裏面早已實現，咱們沒有必要去重複製造輪子。
若是你是應屆生,仍是須要學習各類排序的,參考網址:http://geek.csdn.net/news/detail/113928
JDK8強大了排序功能:parallelSort
parallelSort是java8中新出的一種排序API，
這是一種並行排序，Arrays.parallelSort使用了Java7的Fork/Join框架使排序任務能夠在線程池中的多個線程中進行，
Fork/Join實現了一種任務竊取算法，一個閒置的線程能夠竊取其餘線程的閒置任務進行處理
發現數據量越大，parallelSort的優點就越明顯。
複製代碼
2.查找數組的binarySearch方法
public static int binarySearch(T[] a, T key) 複製代碼
使用二分搜索法來搜索指定類型數組，以得到指定的值。
[重點]必須在進行此調用以前對數組進行排序（經過 sort() 方法）。
若是沒有對數組進行排序，則結果是不肯定的。若是數組包含多個帶有指定值的元素，則沒法保證找到的是哪個。
返回值說明:
一、若是找到關鍵字，則返回值爲關鍵字在數組中的位置索引，且索引從0開始
二、若是沒有找到關鍵字，返回值爲負的插入點值，所謂插入點值就是第一個比關鍵字大的元素在數組中的位置索引，並且這個位置索引從1開始 (-(插入點)),若是數組中的全部元素都小於指定的鍵，則爲(-a.length-1)。
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest08 {
public static void main(String[] args) {
int[] b = new int[]{4, 25, 10, 95, 06, 21};
System.out.println("原數組爲：");
for (int dim1 : b) {
System.out.print("" + dim1 + " ");
}
//必定要先排序
Arrays.sort(b);
System.out.println("排序後爲：");
for (int x : b) {
System.out.print(x + " ");
}
System.out.println();
int index = Arrays.binarySearch(b, 2);
System.out.println("關鍵字2的返回值爲：" + index);
index = Arrays.binarySearch(b, 20);
System.out.println("關鍵字20的返回值爲：" + index);
index = Arrays.binarySearch(b, 30);
System.out.println("關鍵字30的返回值爲：" + index);
index = Arrays.binarySearch(b, 100);
System.out.println("關鍵字100的返回值爲：" + index);
index = Arrays.binarySearch(b, 10);
System.out.println("關鍵字10的返回值爲：" + index);
}
}
複製代碼
結果分析以下:
原數組爲：
4 25 10 95 6 21
排序後爲：
4 6 10 21 25 95
關鍵字2的返回值爲：-1
關鍵字2並無在數組中，並且2比數組中的任何一個元素都小，因此其插入點的值應爲元素4的位置也就是1(沒有找到關鍵字從1開始）
關鍵字20的返回值爲：-4
關鍵字20也不在數組中，數組中第一個比20大的數是21，因此20的插入點值爲4（沒用找到關鍵字從索引從1開始）
關鍵字30的返回值爲：-6
關鍵字30也不在數組中，數組中第一個比30大的數是95，因此30的插入點值爲6（沒用找到關鍵字從索引從1開始）
關鍵字100的返回值爲：-7
關鍵字100也不在數組中，並且100比數組中全部的元素都大，此時插入點值爲length+1 爲7（沒有找到關鍵字索引從1開始）
關鍵字10的返回值爲：2
關鍵字10在數組中，因此返回其在數組中的索引爲2（找到關鍵字索引從0開始）
複製代碼
3.充填數組的fill()方法
用指定的值來填充數組，能夠指定須要填充的索引範圍。
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest09 {
public static void main(String[] args) {
Integer[] a = new Integer[5];
Arrays.fill(a, 2);
System.out.println("當前數組容器："+Arrays.toString(a));
Arrays.fill(a, 5);
// 數字3覆蓋並填滿了整個Array容器
System.out.println("當前數組容器："+Arrays.toString(a));
// 填充的開始位
Integer startIndex = 1;
// 填充的結束位
Integer endIndex = 3;
Arrays.fill(a, startIndex, endIndex, 8);
System.out.println("當前數組容器："+Arrays.toString(a));
}
}
/* 當前數組容器：[2, 2, 2, 2, 2] 當前數組容器：[5, 5, 5, 5, 5] 當前數組容器：[5, 8, 8, 5, 5] */
複製代碼
4.比較兩個數組的equals方法
若是兩個指定類型數組彼此相等，則返回 true。若是兩個數組包含相同數量的元素，而且兩個數組中的全部相應元素對都是相等的，則認爲這兩個數組是相等的。換句話說，若是兩個數組以相同順序包含相同的元素，則兩個數組是相等的。此外，若是兩個數組引用都爲 null，則認爲它們是相等的。
equals方法適用於一維數組，多維數組則使用deepEquals()，用法同equals。
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest10 {
public static void main(String[] args) {
int[] array1={5,6,9,3,2,4};
int[] array2={5,6,9,3,2,4};
int[] array3={6,5,9,3,2,4};
boolean flag1=Arrays.equals(array1,array2); // true
boolean flag2=Arrays.equals(array1,array3); // false
//直接使用equals方法會是什麼結果呢?
boolean flag3 = array1.equals(array2); //堆內存地址不同 false array1==array2
System.out.println(flag1+" "+flag2+" "+flag3);
}
}
複製代碼
5.數組轉字符串toString()方法
返回指定數組內容的字符串表示形式。
字符串表示形式由數組的元素列表組成，括在方括號（"[]"）中。
相鄰元素用字符 ", "（逗號加空格）分隔。
這些元素經過 String.valueOf(short) 轉換爲字符串。若是 a 爲 null，則返回 "null"。
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest11 {
public static void main(String[] args) {
String[] array01 = new String[3];
System.out.println(array01);
System.out.println(Arrays.toString(array01));
String[] array02 = {"悟空","八戒","唐僧"};
System.out.println(array02);
System.out.println(Arrays.toString(array02));
}
}
複製代碼
6.克隆數組的copyOf方法
若是你想擴大數組容量又不想改變它的內容的時候可使用這個方法
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest13 {
public static void main(String[] args) {
int[] array1={5,6,9,3,2,4};
System.out.println("array1的數組長度:"+array1.length);
int[] array2 = Arrays.copyOf(array1,array1.length+1);//根據實際狀況擴容
System.out.println("array2的數組長度:"+array2.length);
array2[0]=100;
System.out.println("array1:"+Arrays.toString(array1));
System.out.println("array2:"+Arrays.toString(array2));
}
}
/** array1的數組長度:6 array2的數組長度:7 array1:[5, 6, 9, 3, 2, 4] array2:[100, 6, 9, 3, 2, 4, 0] */
複製代碼
array1 和 array2 是兩個不相干的數組
7.克隆數組的copyOfRange方法
copyOfRange(int []original,int from,int to)
複製代碼
original爲原始的int型數組，from爲開始角標值，to爲終止角標值。（其中包括from角標，不包括to角標。即處於[from,to)狀態）
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest14 {
public static void main(String[] args) {
int[] array1={5,6,9,3,2,4};
int[] array2 = Arrays.copyOfRange(array1,1,5);
System.out.println("array2的數組長度:"+array2.length);
System.out.println("array2:"+Arrays.toString(array2));
}
}
// 運行結果: array2的數組長度:4
// array2:[6, 9, 3, 2]
複製代碼
這個方法比循環遍歷複製數組效率要高。
8.數組轉列表asList方法
返回一個受指定數組支持的固定大小的列表。（對返回列表的更改會「直接寫」到數組。）此方法同Collection.toArray()一塊兒，充當了基於數組的 API 與基於 collection 的 API 之間的橋樑。返回的列表是可序列化的，而且實現了 RandomAccess。
package com.shxt.demo03;
import java.util.Arrays;
import java.util.List;
public class ArraysTest15 {
public static void main(String[] args) {
Integer[] array1={5,6,9,3,2,4};
List list = Arrays.asList(array1);
System.out.println("list的長度:"+list.size());
}
}
// list的長度:6
複製代碼
避免使用基本數據類型數組轉換爲列表
對上述的代碼改造一下,改成基本數據類型的數組
package com.shxt.demo03;
import java.util.Arrays;
import java.util.List;
public class ArraysTest15 {
public static void main(String[] args) {
int[] array1={5,6,9,3,2,4};
List list = Arrays.asList(array1);
System.out.println("list的長度:"+list.size());
System.out.println(list);
}
}
/** list的長度:1 [[I@4554617c] */
複製代碼
程序的運行結果並無像咱們預期的那樣是 6 而是逆天的 1，這是什麼狀況？
從這個運行結果咱們能夠充分證實 list 裏面的元素就是 int 數組。
轉換爲列表後不能添加元素
package com.shxt.demo03;
import java.util.Arrays;
import java.util.List;
public class ArraysTest15 {
public static void main(String[] args) {
Integer[] array1={5,6,9,3,2,4};
List list = Arrays.asList(array1);
list.add(99);//添加元素
}
}
複製代碼
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:148)
at java.util.AbstractList.add(AbstractList.java:108)
at com.shxt.demo03.ArraysTest15.main(ArraysTest15.java:10)
複製代碼
若是想給列表添加數據,須要從新構造列表
package com.shxt.demo03;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ArraysTest15 {
public static void main(String[] args) {
Integer[] array1={5,6,9,3,2,4};
List list = Arrays.asList(array1);
//再次轉換
List tempList = new ArrayList(list);
tempList.add(666);
//能夠添加
System.out.println(tempList);
}
}
複製代碼
9.數組的哈希碼hashCode
基於指定數組的內容返回哈希碼。對於任何兩個知足 Arrays.equals(a, b) 的同類 型數組 a 和 b，也能夠說 Arrays.hashCode(a) ==Arrays.hashCode(b)。
此方法返回的值與在 List 上調用 hashCode 方法得到的值相同，該 List 包含以相同順序表示 a 數組元素的實例的序列。若是 a 爲 null，則此方法返回 0。
package com.shxt.demo03;
import java.util.Arrays;
public class ArraysTest12 {
public static void main(String[] args) {
int[] array1={5,6,9,3,2,4};
int[] array2={5,6,9,3,2,4};
int[] array3={6,5,9,3,2,4};
System.out.println(Arrays.hashCode(array1));
System.out.println(Arrays.hashCode(array2));
System.out.println(Arrays.hashCode(array3));
System.out.println("---------------------");
//全部的都不同
System.out.println(array1.hashCode());
System.out.println(array2.hashCode());
System.out.println(array3.hashCode());
}
}
/* 1036461630 1036461630 1064167260 --------------------- 1163157884 1956725890 356573597 */
複製代碼
相關文章
- 1. JavaSE基礎:Arrays工具類
- 2. JavaSE基礎:Collections工具類
- 3. JavaSE | 數組 和 Arrays工具類
- 4. Java基礎之Arrays工具類
- 5. Arrays工具類
- 6. Arrays工具類 【vaynexiao】
- 7. JavaSE——Arrays
- 8. Arrays工具類的使用
- 9. Java中Arrays工具類
- 10. Java容器工具類Arrays
- 更多相關文章...
- • jQuery Mobile 工具欄 - jQuery Mobile 教程
- • Kotlin 基礎語法 - Kotlin 教程
- • PHP開發工具
- • Kotlin學習（二）基本類型
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章