Java中的数组
/**************数组的声明*******************/
// 声明整型数组
int[] intArray0 ;
int intArray1 [];
// 声明浮点型数组
float floatArray0 [];
float[] floatArray1 ;
// 声明布尔型数组
boolean boolArray0 [];
boolean[] boolArray1 ;
// 声明字符型数组
char charArray0 [];
char[] charArray1 ;
// 声明字符串数组
String stringArray0[];
String[] stringArray1;
// 错误的声明数组的方式,声明数组的时候不能指定其大小
// int [5] intErrorArray0;
// int intErrorArray1[5];
/*********************数组的创建***********************/
// 创建数组,如果在创建的同时不初始化数组则必须指定其大小
intArray0 = new int[3];
// 错误的创建数组的方式,如果创建数组时不指定大小则必须初始化
// intArray1 = new int[];
// 创建数组时,不指定数组大小则必须在创建的同时初始化数组
intArray1 = new int[]{0,1,2};
System. out.println("intArray0[0]=" + intArray0[0]);
floatArray0 = new float[3];
System. out.println("floatArray0[0]=" + floatArray0[0]);
boolArray0 = new boolean[3];
System. out.println("boolArray0[0]=" + boolArray0[0]);
charArray0 = new char[3];
System. out.println("charArray0[0]=" + charArray0[0]);
stringArray0 = new String[3];
System. out.println("stringArray0[0]=" + stringArray0[0]);
/**********************数组的初始化*************************/
// 静态初始化
int intArray2 [] = new int[]{20,21,22};
// 静态初始化简化方式
int intArray3 [] = {30,31,32};
// 动态初始化
int[] intArray4 = new int[3];
// 错误写法:静态初始化不能指定元素个数
// int intErrorArray5[] = new int[3]{50,51,52};
// 错误写法:动态初始化必须指定元素个数
// int intErrorArray6[] = new int[];
System. out.println("intArray2[0]=" +intArray2 [0]);
System. out.println("intArray3[0]=" +intArray3 [0]);
System. out.println("intArray4[0]=" +intArray4 [0]);
数组工具类1:Java Arrays类
此类包含用来操作数组(比如排序和搜索)的各种方法。文章出自于:
Java程序员的日常—— Arrays工具类的使用
https://www.cnblogs.com/xing901022/p/6224290.html所有的方法都是在下面的类中进行测试的:
public class ArraysTest {
String[] array = new String[]{"a","c","2","1","b"};
Integer[] ints = new Integer[]{5,1,4,3,2};
...
}
asList
这个方法可以把数组转换成List,List提供了很多的操作方法,更便于使用。
@Test
public void test1(){
List<String> lists = Arrays.asList(array);
}
sort排序和parallelSort并行排序
sort比较常用了,根据元素按照自然排序规则排序,也可以设置排序元素的起始位置。
@Test
public void sort(){
/* Arrays.sort(array);
for(String str : array){
System.out.println(str);
}*/
Arrays.sort(array,2,5);
System.out.println(Arrays.deepToString(array));//[a, c, 1, 2, b]
}
parallelSort则采用并行的排序算法排序.但是我自己测试,可能数据量太小,速度上并没有明显的变化。
binarySearch
查找目标元素所在的位置,注意需要先进行排序。
扫描二维码关注公众号,回复:
1886759 查看本文章
@Test
public void binarySearch(){
//binarySearch需要保证是排好序的
System.out.println(Arrays.binarySearch(array,"c"));//-6
Arrays.sort(array);
System.out.println(Arrays.binarySearch(array,"c"));//4
}
copyOf
拷贝数组,第一种用法,如果目标长度不够,会使用0进行补位。第二种用法,支持拷贝目标起始位置到结束为止的数组。
@Test
public void copyOf(){
//如果位数不够,需要补位
Integer[] result = Arrays.copyOf(ints,10);
for(int i : result){
System.out.println(i);
}
System.out.println("----------------------------------------->");
//如果位数够,就取最小的数组
result = Arrays.copyOf(ints,3);
for(int i : result){
System.out.println(i);
}
System.out.println("----------------------------------------->");
//
result = Arrays.copyOfRange(ints,2,4);
for(int i : result){
System.out.println(i);
}
}
deepEquals深度比较、deepHashCode生成hashcode、deepToString深度打印
这几个方法基本都是采用递归的写法使用。
@Test
public void deepTest(){
String[] array2 = new String[]{"a","c","2","1","b"};
System.out.println(Arrays.deepEquals(array,array2));//深度比较两个数组是否相同
System.out.println(Arrays.deepHashCode(array));
System.out.println(Arrays.deepHashCode(array2));//如果两个数组deepEquals,那么他们的hashcode一定相同
//格式化输出数组
System.out.println(Arrays.deepToString(array));
}
equals比较
对比两个数组是否相等
@Test
public void equals(){
String[] array2 = new String[]{"a","c","2","1","b"};
//1 对比引用是否相同
//2 对比是否存在null
//3 对比长度是否相同
//4 挨个元素对比
System.out.println(Arrays.equals(array,array2));
}
fill
基于目标元素填充数组
@Test
public void fill(){
Arrays.fill(array,"test");
System.out.println(Arrays.deepToString(array));//[test, test, test, test, test]
}
toString
打印数组元素
@Test
public void string(){
System.out.println(Arrays.toString(array));//[a, c, 2, 1, b]
}
toStream
把数组转换成stream,然后可以使用java8的stream特性了。
@Test
public void toStream(){
Arrays.stream(array).forEach(s-> System.out.println(s));
}
parallelPrefix
这个有点像spark的reduceByKey,即根据传入的方法一次计算:
@Test
public void parallelPrefix(){
Arrays.parallelPrefix(ints,(x,y)->(x+y));
System.out.println(Arrays.deepToString(ints));//[5, 6, 10, 13, 15]
}
parallelSetAll
这个方法相当于stream.map会挨个元素遍历执行方法
@Test
public void parallelSetAll(){
Arrays.parallelSetAll(ints,x->x*x);
System.out.println(Arrays.toString(ints));//[0, 1, 4, 9, 16]
}
setAll
这个方法与上面类似,只不过不是并行的
@Test
public void setAll(){
Arrays.setAll(ints,x->x*2);
System.out.println(Arrays.toString(ints));
}