数组的定义
数组是相同类型数据的有序(只能用来存储一种类型)集合,可以通过下标访问数值中的所有元素。
数组的基本特点
1、长度是确定的,数组一旦被创建,它的大小就不可改变。
2、数组不能出现混合类型。可以是Java支持的任意类型(基本数据类型和引用数据类型)。
3、数组元素在堆中被分配空间,并且是连续分配。
4、使用new 关键字对数组进行 内存的分配。每个元素都会被jvm 赋予默认值。默认规则:整数:0 浮点数:0.0 字符:\u0000 布尔:false 引用数据类型:null。
5、数组元素是有序的,从0开始。
数组的声明
数组在声明时并没有实例化任何对象,且此数组并没有被真正创建。只有在实例化对象时,JVM才会分配空间,这是与长度有关。
数组初始化
初始化一:int [] arr = new int[3];
初始化二:int [] arr = new int[]{1,2,3};
初始化三:int [] arr = {1,2,3};
数组遍历
for 循环
package testDemo3;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,2,3};
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
foreach循环
package testDemo3;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,2,3};
for (Integer integer : arr) {
System.out.println(integer);
}
}
}
JDK8中的Lambda表达式
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,2,3};
Arrays.asList(arr).forEach(x -> System.out.println(x));
}
}
数组拷贝
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,2,3};
Integer[] arr2 = Arrays.copyOf(arr, arr.length);
System.out.println(Arrays.toString(arr2));
}
}
数组填充
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[3];
Arrays.fill(arr, 8);
System.out.println(Arrays.toString(arr)); // [8, 8, 8]
}
}
数组合并
package testDemo3;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,2,3};
Integer[] arr1 = new Integer[] {4,5};
Integer[] arr2 = new Integer[arr.length + arr1.length];
System.arraycopy(arr, 0, arr2,0, arr.length);
System.arraycopy(arr1, 0, arr2, arr.length, arr1.length);
for (Integer integer : arr2) {
System.out.println(integer.toString()); //1 2 3 4 5
}
}
}
数组排序
正序
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,12,3,27,9,18,4,6};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); //[1, 3, 4, 6, 9, 12, 18, 27]
}
}
逆序
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,12,3,27,9,18,4,6};
Arrays.sort(arr);
for(int i=arr.length-1;i>=0;i--) {
System.out.print(arr[i]+","); //27,18,12,9,6,4,3,1,
}
}
}
冒泡排序
依次相邻的进行比较,把较大(或较小)的放后面,执行整个循环。
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,12,3,27,9,18,4,6};
for(int i = 0;i<arr.length;i++) {
for(int j = 0;j<arr.length-i-1;j++) {
if(arr[j]>arr[j+1]) {
int tem = arr[j+1];
arr[j+1] = arr[j];
arr[j] = tem;
}
}
}
System.out.println(Arrays.toString(arr)); //[1, 3, 4, 6, 9, 12, 18, 27]
}
}
选择排序
每次从待排序元素中选出最大(或最小)的,顺序放在已排好的序列的最后,直到全部待排序的元素全部排完。
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,12,3,27,9,18,4,6};
for(int i = 0;i<arr.length;i++) {
int lowerIndex = i;
for(int j = i+1;j<arr.length;j++) {
//找出最小的索引
if(arr[j]<arr[lowerIndex]) {
lowerIndex = j;
}
}
int temp = arr[i];
arr[i] = arr[lowerIndex];
arr[lowerIndex] = temp;
}
System.out.println(Arrays.toString(arr)); //[1, 3, 4, 6, 9, 12, 18, 27]
}
}
元素查找
采用Arrays.binarySearch(a, key)一定要使元素是正序,即使用之前调用Arrays.sort()方法。
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
Integer[] arr = new Integer[] {1,12,3,27,9,18,4,6};
Arrays.sort(arr);
int index = Arrays.binarySearch(arr, 18);
System.out.println(index);
}
}
多维数组
声明一个二维数组:int[] [] arr = new int[3] [5];
即创建了一个3行5列的数组。
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
Integer[][] arr = new Integer[3][5] ;
for(int i = 0;i<arr.length;i++) {
for(int j = 0;j<arr[0].length;j++) {
arr[i][j] = j;
System.out.print((arr[i][j]));
}
System.out.println();
}
System.out.println();
System.out.println(Arrays.toString(arr[0]));
System.out.println(Arrays.toString(arr[1]));
System.out.println(Arrays.toString(arr[2]));
}
}
结果
01234
01234
01234
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
数组类型转换
字符串转数组
采用split分隔字符串形成数组
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
String str = "ni,hao,shi,jie";
String[] arr = str.split(",");
System.out.println(Arrays.toString(arr)); //[ni, hao, shi, jie]
}
}
数组转字符串
一般采用Arrays.toString()
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
String[] arr = new String[] {"h","e","l","l","o"};
for (String string : arr) {
System.out.print(string); //hello
}
System.out.println();
String str = Arrays.toString(arr);
System.out.println(str); //[h, e, l, l, o]
}
}
数组转集合
采用Arrays.asList()
package testDemo3;
import java.util.Arrays;
import java.util.List;
public class testTwo {
public static void main(String[] args) {
String[] arr = new String[] {"h","e","l","l","o"};
List<String> list = Arrays.asList(arr);
System.out.println(list);
}
}
集合转数组
采用List.toArray()
package testDemo3;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class testTwo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
String[] str = list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(str));
}
}
数组的优、缺点
优点
通过下标访问元素的效率高,指定下标的元素的地址:首地址元素类型字节数;
数组可以保存若干个元素的值。
缺点
数组长度是固定的不能变的;
数组进行元素的删除和插入操作的时候,效率比较低。需要移动大量的元素;
数组元素的类型只能是一种;
数组通过内容查找元素的效率比较低的;
数组的元素是连续分配的,所以在heap内存中必须找到连续的内存空间才能容纳数组的所有数据。对内存要求高一些。
常见面试题集
数组和集合的区别
集合可以存储任意类型的对象数据,数组只能存储同一中类型的数据;
集合的长度是可以发生变化的,数组的长度是固定的;
集合相比较数组功能更强大,数组相比集合效率更高。
数组遍历有哪几种方式
for循环遍历;
foreach循环遍历;
JDK8中的Lambda表达式。
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
String[] arr1 = new String[] {"hello","world"};
String[] arr2 = new String[] {"hello","world"};
System.out.println(Arrays.equals(arr1, arr2)); s
System.out.println(arr1.equals(arr2));
System.out.println(arr1==arr2);
}
}
以上代码的输出结果
true
false
false
Arrays.equals(Object[] a, Object[] a2)为true是因为重写equals方法。源码如下:
public static boolean equals(Object[] a, Object[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; i<length; i++) {
Object o1 = a[i];
Object o2 = a2[i];
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return true;
}
Arrays对象常用哪些方法
Arrays.copyOf() 数组拷贝
Arrays.asList() 数组转集合
Arrays.fill() 数组赋值
Arrays.sort() 数组排序
Arrays.toString() 数组转字符串
Arrays.binarySearch() 二分法查元素
Arrays.equals() 比较两个数组的值
如何查询数组是否包含某值
方法一:Arrays.asList(array).contains(“key”);
方法二:Arrays.binarySearch(array,“key”);
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
String[] arr = new String[] {"hello","world","key","jack"};
boolean bool = Arrays.asList(arr).contains("key");
System.out.println(bool); //true
}
}
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
String[] arr = new String[] {"hello","world","key","jack"};
Arrays.sort(arr);
boolean bool = Arrays.binarySearch(arr, "key") > -1;
System.out.println(bool); //true
}
}
注意:Arrays.binarySearch(a, key)
方法在使用前一定先调用Arrays.sort()方法。
如何对数组其中的元素进行赋值
方式一:
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
int[] arr = new int[6];
for(int i=0;i<arr.length;i++) {
if(i>=2&&i<=4) {
arr[i] = 8;
}
}
System.out.println(Arrays.toString(arr)); //[0, 0, 8, 8, 8, 0]
}
}
方式二:
package testDemo3;
import java.util.Arrays;
public class testTwo {
public static void main(String[] args) {
int[] arr = new int[6];
Arrays.fill(arr, 2, 5, 8);
System.out.println(Arrays.toString(arr)); //[0, 0, 8, 8, 8, 0]
}
}