java数组总结_Java知识点总结 (数组)

Java知识点总结 (数组)

@(Java知识点总结)[Java, Java数组]

[toc]

一维数组

定义

用于存储同一类型数据的一个容器

可以对该容器中的数据从0开始进行编号

数组是对象

声明数组

元素类型 [ ] 变量名 等价 元素类型 变量名 [ ]

元素类型 [ ] 变量名 = new 元素类型 [元素的个数];

元素类型 [ ] 变量名 = ｛元素1，元素2...｝;

元素类型 [ ] 变量名 = new 元素类型[ ]{元素1，元素2...}；

数组元素的个数：__length__

下标运算：[ ]

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 length-1.

场景异常

ArrayIndexOutOfBoundsException(数组下标越界异常)

二维数组

二维数组可以看成以数组为元素的数组，例如：

Java中多维数组的声明和初始化应从高维到低维的顺序进行，例如：

需要两次下标运算才能取出元素

应用：表格、矩阵、棋盘、地图

数组相关算法

数组拷贝

import java.util.Arrays;

/**

* 数组拷贝

* @author Administrator

*

*/

public class ArrayTest2 {

//这样拷贝数组间没有隔离性

public static void test1(){

String[] ss1 = {"1","2","3"};

String[] ss2 = ss1; //把ss1对数组的引用传递给变量ss2，两个变量指向的是同一个数组

ss2[0] = "张三";

System.out.println(ss1[0]); //张三

}

public static void test2(){

String[] ss1 = {"1","2","3"};

String[] ss2 = new String[ss1.length];//通过new关键字在内存中开辟一块空间，ss2指向的是新的数组对象

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

ss2[i] = ss1[i];

}

ss2[0] = "张三";

System.out.println(ss1[0]); //1

}

//API提供的方式，底层用C++写的，所以速度很快，比for循环的效率高

public static void test3(){

String[] ss1 = {"1","2","3"};

String[] ss2 = new String[ss1.length];

System.arraycopy (ss1, 0, ss2, 0, ss1.length);

System.out.println(Arrays.toString(ss2)); // [1, 2, 3]

}

public static void test4(){

String[] ss1 = {"1","2","3"};

String[] ss2 = Arrays.copyOf (ss1, ss1.length);

System.out.println(Arrays.toString(ss2)); //[1, 2, 3]

}

public static void main(String[] args) {

test1();

test2();

test3();

test4();

}

}

数组扩容

import java.util.Arrays;

/**

* 数组扩容

* @author Administrator

*

*/

public class ArrayTest3 {

public static void test1(){

String[] arry1 = {"张三","李四","王五"};

arry1 = Arrays.copyOf (arry1, arry1.length+2);

System.out.println(arry1.length); //5

System.out.println(Arrays.toString(arry1)); //[张三, 李四, 王五, null, null]

}

public static void test2(){

String str = "统计一个字符在字符串中的所有位置";

//int[] arry = countAll(str, '字'); // [4, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

int[] arry = countAll2(str, '字'); // [4, 7]

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

}

//浪费内存

private static int[] countAll(String str,char ch){

char[] charArray = str.toCharArray();

int[] array = new int[charArray.length];

int index = 0;

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

if (ch == charArray[i]) {

array[index] = i;

index ++;

}

}

return array;

}

private static int[] countAll2(String str,char ch){

int[] array = {}; //创建一个空数组

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

if (ch == str.charAt(i)) {

array = Arrays.copyOf(array, array.length+1);

array[array.length-1] = i;

}

}

return array;

}

public static void main(String[] args) {

test1();

test2();

}

}

数组排序

import java.util.Arrays;

/**

* 排序

* @author Administrator

*

*/

public class ArrayTest4 {

// java 提供的排序方法

public static void arraySort(int[] array) {

Arrays.sort(array);

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

}

// 冒泡排序，前一个数与后一个数进行比较

public static void bubbleSort(int[] array) {

int temp = 0;

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

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

if (array[j] < array[i]) {

temp = array[i];

array[i] = array[j];

array[j] = temp;

}

}

}

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

}

// 选择排序

public static void selectSort(int[] array) {

int temp = 0;

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

int min = i;

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

if (array[min] > array[j]) {

min = j;

}

}

if (min != i) {

temp = array[i];

array[i] = array[min];

array[min] = temp;

}

}

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

}

// 插入排序

public static void insertSort(int[] array) {

int temp = 0;

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

for (int j = i; j > 0; j--) {

if (array[j]

temp = array[j];

array[j] = array[j-1];

array[j-1] = temp;

}else break;

}

}

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

}

public static void main(String[] args) {

int[] array = getArray();

bubbleSort(array);

arraySort(array);

selectSort(array);

insertSort(array);

}

private static int[] getArray() {

int[] array = new int[10];

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

array[i] = (int) (Math.random() * 100);

}

return array;

}

}

数组查找

import java.util.Arrays;

/**

* 无序数组 - 顺序查找

* 有序数组 - 二分查找

* @author Administrator

*

*/

public class ArrayTest5 {

//有序数组，二分查找

public static int binarySerarch(int[] array ,int num){

int low = 0;

int high = array.length-1;

while(low <= high){

int mid = (low+high)/2;

if (num>array[mid]) {

low = mid + 1;

}else if (num

high = mid - 1;

}else {

return mid;

}

}

return -1;

}

//Java 提供的查找方式。查看源码，它的本质就是二分查找

public static void test(int[] array ,int num){

int index = Arrays.binarySearch (array, 8);

System.out.println(index);

}

//无序数组,采用遍历，也可以先排序，后采用二分查找

public static int search(int[] array ,int num){

int index = -1;

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

if (num==array[i]) {

index = i;

}

}

return index;

}

public static void main(String[] args) {

int[] array = {2,4,6,8,11,24,45,56,78,92,102};

int index = binarySerarch(array, 8);

System.out.println(index); // 3

test(array, 8); // 3

int[] array1 = {34,21,56,22,1,7,8,3,0,21};

System.out.println(search(array1, 1)); // 4

}

}

Arrays工具类

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的

import java.util.Arrays;

import java.util.List;

public class ArrayTest6 {

public static void main(String[] args) {

int[] nums = new int[10];

//填充数组

Arrays.fill (nums, 3);

System.out.println(Arrays.toString(nums)); //[3, 3, 3, 3, 3, 3, 3, 3, 3, 3]

//将第4个元素到低8个元素的值，赋值为0

Arrays.fill (nums,3,8,0);

System.out.println(Arrays.toString(nums)); //[3, 3, 3, 0, 0, 0, 0, 0, 3, 3]

// 将第3到第5之间的元素进行排序

char[] ch = {'a','d','f','c','j','e'};

Arrays.sort (ch,2,5);

System.out.println(Arrays.toString(ch)); //[a, d, c, f, j, e]

// 比较元素是否相等

char[] ch2 = ch.clone();

System.out.println(Arrays.equals (ch, ch2)); //true 数组元素内容相等

System.out.println(ch == ch2); //false 不是同一个对象

//二分查找

Arrays.sort(ch); //必须先排好序，否则结果不正确

int index = Arrays.binarySearch (ch, 'c');

System.out.println(index); // 1

//数组转为list集合

int[] array1 = {34,21,56,22,1,7,8,3,0,21};

List list1 = Arrays.asList(array1);

System.out.println(list1.size()); //1

Integer[] array2 = {34,21,56,22,1,7,8,3,0,21};

List list2 = Arrays.asList (array2);

System.out.println(list2.size()); //10

for (Integer i : list2) {

System.out.print(i+","); // 34,21,56,22,1,7,8,3,0,21,

}

}

}

数组内存

int score[]; //声明一个整数数组score

此时这个变量并没有包含任何内容，编译器仅仅会分配一块内存给它，用来保存指向数组实体的地址，如图：

声明之后，接着要进行内存分配的操作。这一行代码会开辟3个可供保存整数的内存空间，并把此内存空间的参考地址赋给score变量。如图：

二维数组内存：