- 什么是数组
- 创建数组
- 数组的使用
- 获取长度
- 访问元素
- 遍历数组
- 数组作为方法的参数
- 数组作为方法的返回值
- 数组练习
- 数组转字符串
- 数组拷贝
- 找数组中的最大元素
- 求数组中元素的平均值
- 查找数组中指定元素
- 顺序查找
- 二分查找
- 检查数组有序性
- 冒泡排序
- 数组逆序
- 数组数字排序
- 二维数组
让我们“批量”创建相同类型的变量
创建数组数据类型 [ ] 数组名称=new 数据类型 [ ] {初始化数据};//动态初始化
例:int [ ] arr=new int [ ] {1,2,3,4};
数据类型 [ ] 数组名称= {初始化数据};//静态初始化
例:int [ ] arr= {1,2,3,4};
数组名.length
public class test {
public static void main(String[] args) {
int [] arr={1,2,3};
System.out.println("len="+arr.length);
}
}
访问元素
使用[ ]访问元素以及更改元素,下标从0开始,范围为[0~length-1],防止越界
public class test {
public static void main(String[] args) {
int [] arr={1,2,3};
System.out.println("len="+arr.length);
System.out.println("arr[0]="+arr[0]);
System.out.println("arr[1]="+arr[1]);
System.out.println("arr[2]="+arr[2]);
arr [1]=298;//修改下标为1的元素
System.out.println("修改后arr[1]="+arr[1]);
}
}
System.out.println("arr[4]="+arr[4]);
数组越界异常:
1、循环遍历
public class test {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) {
System.out.println("arr" +"["+ i+"]" + "=" + arr[i]);
}
}
}
2、使用for-each遍历
public class test {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
for (int x:arr) {
System.out.println("arr" +"["+ x+"]" + "=" + x);
}
}
}
数组作为方法的参数
数组名是“引用”,数组传参,是按照引用传参,相当于传的是一个地址。
public class test {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
System.out.println("arr[0]="+arr[0]);
fun(arr);
System.out.println("arr[0]="+arr[0]);
}
public static void fun(int [] arr){
arr [0]=100;
}
}
传地址过去形参的改变影响实参的改变
传值形参改变就不会影响实参
public class test {
public static void main(String[] args) {
int a=1;
System.out.println("a="+a);
fun(a);
System.out.println("a="+a);
}
public static void fun(int a){
a=100;
}
}
数组作为方法的返回值
将数组的元素翻倍
public class test {
public static void main(String[] args) {
int [] arr={1,2,3,4,5};
transArray(arr);
printArray(arr);
}
public static void printArray(int [] arr){
for(int x:arr){
System.out.print(x+" ");
}
}
public static void transArray(int [] arr){
for(int i=0;i
arr [i]=arr[i]*2;
}
}
}
但是这种方法直接改变了数组之前的值
要是不想改变原来的值,就得返回一个新的数组
public class test {
public static void main(String[] args) {
int [] arr={1,2,3,4,5};
int [] newarr=transArray(arr);
printArray(arr);
System.out.println();
printArray(newarr);
}
public static void printArray(int [] arr){
for(int x:arr){
System.out.print(x+" ");
}
}
public static int [] transArray(int [] arr){
int [] ret=new int [arr.length];
for(int i=0;i
ret [i]=arr[i]*2;
}
return ret;
}
}
数组练习
数组转字符串
1、利用字符串拼接完成
public class test {
public static void main(String[] args) {
int [] arr ={1,2,3,4,5,6};
System.out.println(toString(arr));
}
public static String toString(int [] arr){
String ret ="[";
for(int i=0;i
ret+=arr[i];
if(i
ret+=",";
}
}
ret+="]";
return ret;
}
2、利用java.util.Arrays这个包提供的toString方法直接转换
import java.util.Arrays;
public class test {
public static void main(String[] args) {
int [] arr={1,2,3,4,5,6};
String newArr= Arrays.toString(arr);
System.out.println(newArr);
}
}
数组拷贝
1、创建一个新的数组直接一一拷贝
public class test {
public static void main(String[] args) {
int [] arr={1,2,3,4,5,6};
int [] newArr=copy(arr);
for(int x:newArr){
System.out.print(x+" ");
}
}
public static int [] copy(int [] arr){
int [] ret=new int [arr.length];
for(int i=0;i
ret [i]=arr[i];
}
return ret;
}
}
2、利用java.util.Arrays提供的数组拷贝方法
import java.util.Arrays;
public class test {
public static void main(String[] args) {
int [] arr ={1,2,3,4,5,6};
int [] newArr=Arrays.copyOf(arr,arr.length);//深拷贝
System.out.println("newArr:"+Arrays.toString(newArr));
arr[0]=10;
System.out.println("arr:"+Arrays.toString(arr));//原来数组的改变不影响拷贝后的数组
System.out.println("newArr:"+Arrays.toString(newArr));
int [] newArr1=Arrays.copyOfRange(arr,2,5);//范围拷贝:[2~5)
System.out.println("newArr1:"+Arrays.toString(newArr1));
}
}
找数组中的最大元素
public class test {
public static void main(String[] args) {
int [] arr={11,2,34,56,34,56,78,92,1};
System.out.println(Max(arr));
}
public static int Max(int [] arr){
int max=0;
for(int i=0;i
if(arr[i]>max){
max=arr[i];
}
}
return max;
}
}
求数组中元素的平均值
由于结果可能位小数,所以这里用double类型表示
public class test {
public static void main(String[] args) {
int [] arr ={1,23,45,4,6,77,9};
System.out.println(Avg(arr));
}
public static double Avg(int [] arr){
int sum=0;
for(int x:arr){
sum+=x;
}
return (double) sum/(double) arr.length;
}
}
查找数组中指定元素
顺序查找
public class test {
public static void main(String[] args) {
int [] arr ={1,23,45,89,67,90,78,};
System.out.println(Find(arr,89));
}
public static int Find(int [] arr,int tofind){
for(int i=0;i
if(arr[i]==tofind){
System.out.print("找到了,下标为:");
return i;
}
}
return -1;//找不到返回-1
}
}
二分查找
针对有序数组,二分查找效率更高
public class test {
public static void main(String[] args) {
int [] arr ={1,2,3,4,5,6,7,8,9,10};
System.out.println(binarysearch(arr,6));
}
public static int binarysearch(int [] arr,int n){
int left=0;
int right=arr.length-1;
while(left<=right){
int mid=(left+right)/2;
if(arr[mid]
left=mid+1;
}else if(arr [mid]>n){
right=mid-1;
}else {
System.out.println("找到了,下标为:");
return mid;
}
}
System.out.println("没找到");
return -1;
}
}
元素个数越多,效率就越高
public class test {
static int count=0;
static int count1=0;
public static void main(String[] args) {
int [] arr=createBigArray();
int ret =binarySearch(arr,9999);
int ret1=Find(arr,9999);
System.out.println("ret="+ret+" count="+count);
System.out.println("ret1="+ret1+" count1="+count1);
}
public static int [] createBigArray(){
int [] arr=new int [10000];
for(int i=0;i<10000;i++){
arr[i]=i;
}
return arr;
}
public static int binarySearch(int [] arr,int n){
int left=0;
int right =arr.length-1;
while(left<=right){
count++;
int mid=(left+right)/2;
if(arr[mid]>n){
right=mid-1;
}else if(arr[mid]
left=mid+1;
}else{
return arr[mid];
}
}
return -1;
}
public static int Find (int []arr,int tofind){
for(int i=0;i
count1++;
if(arr[i]==tofind){
return arr[i];
}
}
return -1;
}
}
数据多的时候,二分查找次数明显比顺序查找次数少了很多
给定一个数组,检查这个数组是否为升序或降序,仅需要判断后一个元素是否大于或者小于前一个即可(若有重复元素,加上=的条件)
public class test {
public static void main(String[] args) {
int [] arr={1,2,3,6,7,8,9};
System.out.println(isAsc(arr));
}
public static boolean isAsc(int [] arr){
for(int i=0;i
if(arr[i]>arr[i+1]){
return false;
}
}
return true;
}
}
冒泡排序
给定一个数组,让数组升序排列,每次找到当前待排序区间的最小或者最大的元素,放到数组最前面或者最后面,降序同理。
import java.util.Arrays;
public class test {
public static void main(String[] args) {
int [] arr ={2,1,3,4,7,9,6,8,5};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int [] arr){
for(int i=0;i
for(int j=0;j
if(arr[j]>arr[j+1]){
int tmp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
}
}
}
}
}
在Java中提供了一个更高效的排序方法
import java.util.Arrays;
public class test {
public static void main(String[] args) {
int []arr={2,3,1,5,7,4,9,8,6};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
数组逆序
import java.util.Arrays;
public class test {
public static void main(String[] args) {
int []arr={1,2,3,4};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static void reverse(int []arr){
int left =0;
int right=arr.length-1;
while(left
int tmp=arr[left];
arr[left]=arr[right];
arr[right]=tmp;
left++;
right--;
}
}
}
数组数字排序
将一个数组的偶数部分放在前面,奇数部分放在后面
public class Test {
public static int[] Swap(int[] arr){
int left=0;
int right=arr.length -1;
while(left
if(arr[left]%2==0) {
left++;
}
if(arr[right]%2!=0){
right--;
}
int tmp=arr[left];
arr[left]=arr[right];
arr[right]=tmp;
left++;
right--;
}
return arr;
}
public static void main(String[]args){
int []array={1,2,3,4,5,6};
String ret= Arrays.toString(array);
System.out.println(ret);
System.out.println("===================");
String ret1=Arrays.toString(Swap(array));
System.out.println(ret1);
}
}
二维数组
二维数组本质上也是一维数组,只不过里面的每个元素又是一个一维数组
初始化方式:
1、数据类型[][]数组名={{数据},{数据}……};
int [] []arr={{1,2,3},{4,5,6}};
2、数据类型 [ ] [ ] 数组名=new 数据类型[ 行数] [列数 ] ;
int [] [] arr=new int [2][3];
3、数据类型 [ ] [ ] 数组名=new 数据类型[ ] [] {{数据},{数据}……};
int [] [] arr=new int [][]{{1,2,3},{4,5,6}};
public class test {
public static void main(String[] args) {
int [] []arr={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for(int row =0;row//arr.length 为二维数组的行数
for(int col=0;col
System.out.printf("%dt",arr[row][col]);
}
System.out.println(" ");
}
}
}



