1.1数组是一组元素的线性集合。
（1）类C的语法：
int a[] //定义一个元素类型是int的数组，名称是a
（2）Java中更推荐的写法：
int[] a ?//定义一个元素类型是int的数组，名称是a
注意：下标（index）从0开始
1.2元素类型[]：本身作为一种合法的数据类型，可以出现在任何需要数据类型的位置
long/String/Scanner/Random/boolean……[]
（1）定义变量 ?int[] a;
（2）定义方法时，可以出现在
?????返回值类型：public static int[] method{……}
?????形参列表:public static ?void ?main(String[] args){……}
（3）作为数组的元素类型使用
?????int[][]
?//定义了一个数组。数组的元素类型是int[]（元素类型是int的数组） ?
2.数组的初始化（初始化不是赋值）
? int a={1,2,3,4}
（1）定义int类型的数组
（2）为其进行初始化操作——数组中共有4个元素，对应的下标为0,1,2,3
3.既可以用于初始化，也可以用于赋值
（1）已知元素时——可以根据后面的元素推导长度，不需要也不允许传长度
???int[] a=?new int[]{1,2,3,4}
（2）不知元素，但总长度已知
???int[] a=?new int[5]
?//定义了一个int数组，长度是5，这个5必须有，因为长度不变
如果：没有明确元素值得情况下，元素的默认值是什么？
每种变量都有其默认值（局部变量没有初始值）
实际上是0的变形值：
byte/short/int ?????0
long ???????????????0L
float ??????????????0.0F
double ????????????0.0
boolean ???????????false
char ??????????????0x0000对应的字符
引用类型 ??????????null*
4.关于数组类型的常见操作
（1）从数组中获取下标为i的元素（i>=0且<=数组长度）
int[] a={1,2,3,4};
int b=a[3]; //取a数组中下标为3的元素，类型是intb==4
nt[] a=new int[5];
int b=a[3]; //取a数组中下标为3的元素，类型是intb==0
如果下标没有在合法范围内（0<=i<数组长度），会有运行时异常：
IndexOutOfBoundsException（下标越界异常）——初期最常见的异常
?（2）获取数组的长度
???int[]a=……；? 唯一方法： a.length?
5.下标[]
作用（1）：获取数组中某下标位置的元素——int b=a[i]; ????取
作用（2）：修改数组中某下标位置的元素——a[i]=b; ????????设置
6.打印数组中的元素
java.util.Arrays类中有toString方法，方便直接打印数组
int[] a=……；
String s=Arrays.toString(a);
System.out.println(s);
代码练习：
- 从前往后遍历——用下标的角度i~[0,array.length]
public class 代码练习1 { public static int indexOf(long[] array,long target){ for (int i=0;i< array.length;i++) { long element = array[i]; if (element == target) { return i; } } return -1;//超过合法下标，数组中没有找到target } }替换成带范围的后：
/替换成带范围的后[fromIndex,toIndex)
public static int indexOf(long[] array,int fromIndex,int toIndex,long target){
if (fromIndex<0||fromIndex>toIndex||toIndex>array.length){
throw new RuntimeException("传入的参数不合法");
}
for (int i=fromIndex;i<toIndex;i++){
if (array[i]==target){
return i;
}
}
return -1;
}
}
?练习1测试：
public class 练习1测试 {
public static void main(String[] args) {
test1();
}
private static void test1() {
long[] a1={1,2,3,4,5};
System.out.println(代码练习1.indexOf(a1, 1));//0
System.out.println(代码练习1.indexOf(a1, 5));//4
System.out.println(代码练习1.indexOf(a1, -1));//-1
System.out.println(代码练习1.indexOf(a1, 6));//-1
}
}?2.从后往前遍历
public class 代码练习2 {
public static int lastIndexOf(long[] array,long target) {
//从后往前找
for (int i=array.length-1;i>=0;i--){
long element=array[i];
if (element==target){
return i;
}
}
return -1;
}
}练习2测试：
public class 练习2测试 {
public static void main(String[] args) {
test2();
}
private static void test2() {
long[] a1={1,2,3,4,3,2,1};
System.out.println(代码练习2.lastIndexOf(a1,2,5,1));//-1
System.out.println(代码练习2.lastIndexOf(a1,2,5,3));//4
}
}3.找到数组中的最大值
public class 代码练习3 {
//不考虑数组长度为0的情况
//new int[0];
public static long max(long[] array){
long max=array[0];
for (int i=1;i<array.length;i++){
if (array[i]>max){
max=array[i];
}
}
return max;
}
}4、计算数组中元素之和
public class 代码练习4 {
//不考虑溢出的情况
public static long sum(long[] array){
long sum=0;
for (long element:array){
sum+=element;
}
return sum;
}
}替换成带范围的后：
//替换成带范围的后[fromIndex,toIndex)
public static long sum(long[] array, int fromIndex, int toIndex) {
long sum = 0;
for (int i = fromIndex; i < toIndex; i++) {
sum += array[i];
}
return sum;
}
}5、给定元素将其填充到数组中的每一个位置
public class 代码练习5 {
public static void fill(long array[],long target){
for (int i=0;i<array.length;i++){
array[i]=target;
}
}
}Java.util.Arrays类中的各种方法
- 学会常见的方法使用（尽量不要自己造）
- 学会查阅文档
import java.util.Arrays ;
public class 使用arrays中的方法 {
public static void main(String[] args) {
testBinarySearch();
}
private static void testBinarySearch() {
long[] a={1,2,3,4,4,5,6,7,8,9};
System.out.println(Arrays.binarySearch(a, 3));//2
System.out.println(Arrays.binarySearch(a, 4));//3 OR 4
System.out.println(Arrays.binarySearch(a, -1));//-1
System.out.println(Arrays.binarySearch(a, 10));//-11非法下标
}
}
- 传入数组返回数组对应的字符串形式
public class MyArrays { //"[1,2,3,4]" public static String toString(long[] array){ //遍历(下标遍历方式) String ans="["; //遍历除最后一个元素之外的其他所有元素 for (int i=0;i<array.length-1;i++){ long element=array[i]; ans=ans+element+","; } //把最后一个元素添加到字符串ans中 //数组中最后一个元素的下标是array.length-1 //array.length的取值范围是>=0 if (array.length>0){ long lastElement=array[array.length-1]; ans=ans+lastElement; } ans+="]"; return ans; } }测试：
public class MyArraysTest {
public static void main(String[] args) {
test1();
}
private static void test1() {
long[] arrays;
String s;
arrays=new long[0];
s=MyArrays.toString(arrays);
System.out.println(s);
arrays=new long[5];
s=MyArrays.toString(arrays);
System.out.println(s);
arrays=new long[]{1,2,3,4,5};
s=MyArrays.toString(arrays);
System.out.println(s);
}2.
public static long[] copyOf(long[] original,int newLength){
long[] ans=new long[newLength];
//下标i停留位置应该在original.length和ans.length中小的一个位置上
int size=Integer.min(original.length,newLength);
for (int i=0;i<size;i++){
//需要保证=两边下标的合法性
ans[i]=original[i];
}
//如果newLength>original.length了，ans中剩余的位置已经是long类型的默认值（0）
return ans;
}
}测试：
private static void test2() {
long[] original={1,2,3};
long[] c1 = MyArrays.copyOf(original, 1);
System.out.println(MyArrays.toString(c1));
long[] c2 = MyArrays.copyOf(original, 3);
System.out.println(MyArrays.toString(c2));
long[] c3 = MyArrays.copyOf(original, 4);
System.out.println(MyArrays.toString(c3));
}3、
public static long[] copyOfRange(long[] original,int from,int to){
if (from<0){
throw new RuntimeException("from必须>=0");
}
if (from>0){
throw new RuntimeException("from必须<=0");
}
if (from>original.length){
throw new RuntimeException("from必须<=original.length");
}
int newLength=to-from;
long[] ans=new long[newLength];
/*假如i代表的是ans的下标，i的合法取值范围包含两个条件
（1）i在ans中是合法下标[0,ans.length)
（2）from+i在original中是合法下标[0,original.length)
i的取值范围[-from,original.length-from)
综上所述，i的合法范围是[0,ans.length)和[-from,original.length-from)的交集
i~[0,min(ans.length,original.length-from)
*/
int size=Integer.min(newLength,original.length-from);
for (int i=0;i<size;i++){
ans[i]=original[from+i];
}
return ans;
}
}测试：
private static void test3() {
long[] original={1,2,3};
long[] c1 = MyArrays.copyOfRange(original, 0, 0);
System.out.println(MyArrays.toString(c1));
long[] c2 = MyArrays.copyOfRange(original, 0, 2);
System.out.println(MyArrays.toString(c2));
}
4、冒泡排序
public static void bubbleSort(long[] array){
//
for (int i=0;i<array.length-1;i++){
/*每循环一次经过一次“冒泡过程”，把无序区间中的最大的数冒泡到无序区间的最后位置
数组看做一个整体区间，表示[0,array.length)
（1）无序区间：[0,array.length-i)，实现具体的冒泡过程：
j~[0,array.length-i) j+1~[0,array.length-i)于是j~[-1,array.length-i-1)
取交集为 j~[0,array.length-i-1)
*/
for (int j=0;j<array.length-i-1;j++){
//j需要保证array[j]和array[j+1]的下标的合法性
if (array[j]>array[j+1]){
//交换
long t=array[j];
array[j]=array[j+1];
array[j+1]=t;
}
}
}
}测试：
private static void test4() {
long[] array;
array=new long[]{1,2,3,4,5,6};//有序情况
MyArrays.bubbleSort(array);
System.out.println(MyArrays.toString(array));
array=new long[]{1,6,8,9,13,5};//无序情况
MyArrays.bubbleSort(array);
System.out.println(MyArrays.toString(array));
array=new long[]{};//空序情况
MyArrays.bubbleSort(array);
System.out.println(MyArrays.toString(array));
}5、二分法查找
public static int binarySearch(long[] array,long target){
//待查找区间[low,high)，待查找区间内元素个数为high-low;
//定义待查找区间的下限
int lowIndex=0;
//定义待查找区间的上限
int highIndex=array.length;
//只要待查找区间中还有元素查找就要继续
while (highIndex-lowIndex>0){
int midIndex=(lowIndex+highIndex)/2; //暂时不考虑溢出情况
long midElement=array[midIndex];
if (target==midElement){
return midIndex;
}
else if (target<midElement){
//需要扔掉右边[MidIndex，……)
//highIndex是开区间，虽等于但是区间内并没有midIndex的元素
highIndex=midIndex;
}else{
//需要扔掉左边[……，MidIndex]
//lowIndex是闭区间，所以等于midIndex+1，区间里没有midIndex对应的元素
lowIndex=midIndex+1;
}
}
//high-low<0换言之，待查找区间内一个元素都没有了，说明target不在array中
return -1;
}