数组的基本概念
数组是储存多个相同类型的元素，虽然数组中的元素均为基本元素,但是Java中使用了类似对象的处理方式处理数组。在数组的初始化中使用new进行初始化。
创建一个一维数组
定义数组的方式为:
数组元素类型 [ ]数组名;如下实例
int arr1[]; //定义一个int类型的数组
int []arr2;
String []arr3; //定义一个String类型的数组
char []arr4; //定义一个字符类型数组
boolean []arr5; //定义一个boolean类型数组
数组定义中中括号[ ]可以在数组名的前面或者后面,表达式效果相同，Java中推荐放在数组名前。
数组定义后还不能对数组进行访问，因为定义中只是声明了数组的类型和数组名，想要真正让数组发挥作用还需要对数组进行初始化，为当前数组分配内存空间。
数组的初始化
数组的初始化分为静态初始化和动态初始化两种。
动态初始化
动态初始化中需要给数组指定一个长度，语法格式为：
//先定义再初始化.
int []arr1;
arr1=new int[6];
//定义和初始化一起执行.
int []arr2=new int [5];int []arr1=new int[5];
System.out.println(arr1[2]);
//此时会输出 0
String []arr2=new String[3];
System.out.println(arr2[2]);
//此时会输出 null
boolean []arr3=new boolean[4];
System.out.println(arr3[2]);
//此时会输出 false静态初始化
静态初始化中需要给定数组中的元素的值，由系统计算数组的长度。语法格式为：
int []arr=new int[]{1,2,3,4,5};
int []arr2={3,4,5,6};//int []arr=new int[5]{1,2,3,4,5};
//这种书写方式是错误的，数组的初始化中静态初始化和动态初始化只能选择一种。数组的应用
数组的遍历
for循环遍历。
public class TextDemo {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
out(arr);
}
public static void out(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.println(arr[i] + "]");
} else {
System.out.print(arr[i] + ", ");
}
}
}
}
//输出结果为[1, 2, 3, 4, 5, 6, 7, 8, 9]
需要注意描述数组的长度时数值从1开始，操作数组中的元素时的脚标从0开始如：
int [ ]arr=new int[ 3 ];
arr这个数组中包含了arr[0],arr[1],arr[2]这三个元素。
arr.length表示当前数组的长度。
使用Arrays类中的toString方法遍历数组
此方法可以将数组转化成字符串遍历输出。
该方法为静态方法使用类名调用。
import java.util.Arrays;//需要导包
public class arr {
public static void main(String[] args) {
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
System.out.println(Arrays.toString(arr));
int[][] arr2 = { { 1, 2, 3 }, { 4, 5, 6 } };
System.out.println(Arrays.toString(arr2[0]));
System.out.println(Arrays.toString(arr2[1]));
}
}
/**输出为：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3]
[4, 5, 6]
*/使用String拼接
public class buffer {
public static void main(String[] args) {
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
String a = new String();
a += "[";
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
a += arr[i];
a += "]";
} else {
a += arr[i];
a += ", ";
}
}
System.out.println(a);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
}
使用StringBuffer中的append方法
public class buffer {
public static void main(String[] args) {
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
StringBuffer a = new StringBuffer("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
a.append(arr[i]+"]");
} else {
a.append(arr[i]+", ");
}
}
System.out.println(a);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
}数组元素的逆序
public class TextDemo {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
out(arr);
reversed(arr);
out(arr);
}
public static void reversed(int[] arr) {
//数组逆序排列
for(int i=0;i<=arr.length/2;i++) {
int temp=arr[i];
arr[i]=arr[arr.length-1-i];
arr[arr.length-1-i]=temp;
}
}
public static void out(int[] arr) {
//打印数组
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.println(arr[i] + "]");
} else {
System.out.print(arr[i] + ", ");
}
}
}
}
/**输出为：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1]
*/
数组中的元素的查找
基本查找法
import java.util.Scanner;
public class TextDemo {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 4, 3, 2, 1 };
find(arr);
}
public static void find(int[] arr) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入要查询的数:");
int a = sc.nextInt();
int j = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == a) {
System.out.println("该元素在当前数组的第" + (i+1) + "位。");
j++;
}
}
if (j == 0) {
System.out.println("该元素不在当前数组中。");
}
}
}
/**输入为3时的输出：
请输入要查询的数:
3
该元素在当前数组的第3位。
该元素在当前数组的第7位。
*/
/**输入为7时的输出：
请输入要查询的数:
7
该元素不在当前数组中。
*/
折半查找法
折半查找是每次去出需要查找的中间值，然后和需要查找的数进行比较，大的话就从左边的再进行折半查找，小的话就从右边开始折半查找，最终找到相等的值时返回此时的下标。
折半查找法需要数组是按从小到大排列的，如果数组不是有序的还是使用基本查找法。
import java.util.Scanner;
public class ArrayDemo3 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
System.out.println("请输入要查询的元素");
Scanner sc = new Scanner(System.in);
int index = search(arr, sc.nextInt());
if (index == -1) {
System.out.println("查找元素不在数组中");
} else {
System.out.println("查找元素下标为:" + index);
}
}
public static int search(int[] arr, int value) {
// 1定义数组中的最小索引和最大索引
int min = 0;
int max = arr.length - 1;
// 2 计算出中间索引
int mid = (max + min) / 2;
// 3)拿中间索引对应的元素和需要查找的元素进行比较
// 如果相等,返回
while (arr[mid] != value) {
// 不相等
if (arr[mid] > value) {
max = mid - 1;
} else {
min = mid + 1;
}
// 如果这value在数组中找不到,找不到返回-1
if (min > max) {
return -1;
}
// 重新计算出中间索引
mid = (max + min) / 2;
}
return mid;
}
}
/**
请输入要查询的元素
10
查找元素下标为:9
请输入要查询的元素
55
查找元素不在数组中
* */数组的排序
将一个数字数组按从小到大顺序排列
冒泡排序法
此方法是依次比较数组中前后两个数的大小，前一个比后一个大则交换，每次循环后会将最大的数换到最后。
import java.util.Arrays;
public class Arr {
public static void main(String[] args) {
int[] arr = { 2, 5, 6, 9, 1, 3, 8, 4, 10, 7 };
System.out.println(Arrays.toString(arr)); // Arrays.toString方法遍历数组
for (int i = 0; i < arr.length; i++) { // 控制循环排序次数,一共进行数组长度-1次
for (int j = 0; j < arr.length - 1 - i; j++) { // 依次对比将大的交换到最后，每遍历过一次后比较的次数-1
//注意因为有arr[j + 1]，所以j的取值只能取到数组长度-1次，不然会超出范围
if (arr[j] > arr[j + 1]) {
int temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
// [2, 5, 6, 9, 1, 3, 8, 4, 10, 7]
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]比较排序法
抽取第一个元素然后和之后所有元素比较，谁比他小就交换，最终会将最小的排在第一个，然后再抽取下一位。
import java.util.Arrays;
public class Arr {
public static void main(String[] args) {
int[] arr = { 2, 5, 6, 9, 1, 3, 8, 4, 10, 7 };
System.out.println(Arrays.toString(arr));
for (int i = 0; i < arr.length - 1; i++) {// 控制循环进行的次数
for (int j = i + 1; j < arr.length; j++) { // 从抽取的数的下一位开始依次比较
if (arr[i] > arr[j]) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
// [2, 5, 6, 9, 1, 3, 8, 4, 10, 7]
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]对象数组
用来存储对象的数组
class Student {
// 创建一个学生类
String name;
int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [姓名=" + name + ", 年龄=" + age + "]";
}
}
public class Arr {
public static void main(String[] args) {
// 创建对象数组
Student[] stuarr = new Student[4];
// 创建4个学生对象
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 24);
Student s3 = new Student("王五", 21);
Student s4 = new Student("赵六", 20);
// 赋值
stuarr[0] = s1;
stuarr[1] = s2;
stuarr[2] = s3;
stuarr[3] = s4;
// 遍历
for (int i = 0; i < stuarr.length; i++) {
System.out.println(stuarr[i].toString());
}
}
}
/**
Student [姓名=张三, 年龄=23]
Student [姓名=李四, 年龄=24]
Student [姓名=王五, 年龄=21]
Student [姓名=赵六, 年龄=20]
*/二维数组
二维数组的定义：
//动态初始化;
int [][]arr=new int[3][2];
int []arr2[]=new int[3][2];
int arr3[][]=new int[3][2];
//静态初始化
int [][]arr4=new int[][]{{3,5,8,9},{1,2,3,5}};
int [][]arr5= {{1,4,5,8,9},{1,1,2,5,5}};
二维数组中第一个元素相当于定位到第几个一维数组,也就是说一维数组是一些类型相同的元素的集合,二维数组是一些元素相同的一维数组的集合.
动态初始化还可以动态定义每一个一维数组的长度:
//通过动态给定每个一维数组的长度
arr[0]=new int[2];
arr[1]=new int[1];
arr[2]=new int[4];
arr[2][3]= 5; //该元素是arr[2][]的最后一个元素,而不是arr[2][4].
System.out.println(arr[2][3]);需要注意此时定义的是长度,也就是说
arr[2]=new int[4];此时定义的是第三个一维数组的长度为4,则这个数组的最后一个元素为arr[2][3].
如果在调用中写成arr[2][4]则会发生异常ArrayIndexOutOfBoundsException
二维数组的遍历:
public class ARRTEXT {
public static void main(String[] args) {
int[][] arr = { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9 }, { 10, 11 } };//静态初始化二维数组
printArray(arr);
}
public static void printArray(int[][] arr) {
for (int x = 0; x < arr.length; x++) {
for (int y = 0; y < arr[x].length; y++) {
System.out.print(("["+arr[x][y] + "] "));
}
System.out.println();
}
}
}
//输出结果为:
/*
[1] [2] [3] [4] [5]
[6] [7] [8] [9]
[10] [11]
*/Arrays工具类
Java中为我们提供了数组相关的一个工具类，使用该工具类可以方便的输出编辑数组。
工具类只有静态方法。
toString()
将数组转化为字符串，有多个重载方法，可以支持boolean、float、int、long、short对象数组。
sort()
将数组升序排列，是一个改进的快速排序，比起传统的冒泡，选择排序速度更快
binarySearch(int[] a,int key)
二分法查找数组，返回值为int型
import java.util.Arrays;
//使用Arrays工具类需要导包。
public class test {
public static void main(String[] args) {
int arr[] = { 5, 4, 8, 9, 6, 7, 1, 2, 3 };
// 遍历数组
System.out.println(Arrays.toString(arr));// [5, 4, 8, 9, 6, 7, 1, 2, 3]
// 数组升序排列
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
// 查找4在当前数组中的位置，使用二分法查找
System.out.println(Arrays.binarySearch(arr, 4));
}
} asList(T... a)
public static <T> List<T> asList(T... a)
将数组转化成固定大小的集合，该集合的长度不可变，添加删除等相关功能都会报错。
import java.util.Arrays;
import java.util.List;
public class test {
public static void main(String[] args) {
String[] s = { "java", "word", "hello", "google" };
// 转换成固定长度的集合
List<String> list = Arrays.asList(s);
// list.add("android"); UnsupportedOperationException不支持该操作
// 可以使用替换
list.set(2, "android");
for (String st : list) {
System.out.print(st + " ");// java word android google
}
}
}异常
数组中常见的异常：
ArrayIndexOutOfBoundsException:数组角标越界异常
访问了定义中不存在的数组角标，属于运行中异常，编译的时候可以通过。
解决办法可以在代码中加入非空判断，当数组不为空的时候才可以输出。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
