java数组算法

1.数组的概述

• 多个相同类型的数据按照一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

• 数组相关的概念：

  • 数组名

  • 下标（或索引、角标）

  • 元素

  • 数组的长度，元素的个数

• 数组的特点：

  • 数组是有序排列的

  • 数组属于引用数据类型的变量，数组的元素可以是基本数据类型，也可以是引用数据类型

  • 创建数组对象会在内存中开辟一整块连续的空间

  • 数组的长度一旦确定，就不能修改

• 数组的分类：

  • 按照维数，一维数组、二维数组......

  • 按照数组元素类型，基本数据类型元素的数组、引用数据类型元素的数组

2.一维数组的使用

• 一维数组的声明和初始化

  • 数组一旦初始化完成，其长度就确定了

• 如何调用数组的指定位置元素：通过角标的方式调用

  • 数组的角标（或索引）从0开始，到数组的长度-1结束。

• 如何获取数组的长度

• 如何遍历数组

• 数组元素的默认初始化值

  • 数组元素是整型：0

  • 数组元素是浮点型：0.0

  • 数组元素是char型：0或'\u0000',而非'0'

  • 数组元素是boolean型：false

  • 数组元素是引用数据类型：null

• 数组的内存解析

 

 

//一维数组的声明和初始化
int num;//声明
num=10;//初始化
int id=1001;//声明+初始化

int[] ids;//声明
//静态初始化：数组初始化和数组元素的赋值操作同时进行
ids=new int{1001,1002,1003};
//动态初始化：数组初始化和数组元素的赋值操作分开进行
String[] names=new String[5];

//如何调用数组的指定位置元素:通过角标的方式调用
//数组的角标（或索引）从0开始，到数组的长度-1结束。
names[0]="张三";
names[1]="李四";
names[2]="王二";
names[3]="小明";
names[4]="老王";

//如何获取数组的长度
//属性：length
 System.out.println(names.length);//5
 System.out.println(ids.length);//3

//如何遍历数组
for(int i=0;i<names.length;i++){
   System.out.println(names[i]);
}

//数组元素的默认初始化值
int[] arr=new int[4];
for(int i=0;i<arr.length;i++){
   System.out.println(arr[i]);
}

short[] arr1=new short[4];
for(int i=0;i<arr1.length;i++){
   System.out.println(arr1[i]);
}

char[] arr3=new char[4];
for(int i=0;i<arr3.length;i++){
   System.out.println(arr3[i]);
}

boolean[] arr4=new boolean[4];
for(int i=0;i<arr4.length;i++){
   System.out.println(arr4[i]);
}

String[] arr5=new String[4];
for(int i=0;i<arr5.length;i++){
   System.out.println(arr5[i]);
}

//数组的内存解析

 

练习1：

升景坊单间短期出租4个月，5550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静，所以要求来租者最好是同行业年轻人，爱干净、安静。

int[] arr=new int{8,2,1,0,3};
int[] index=new int{2,0,3,2,4,0,1,3,2,3,3};
String tel="";
for(int i=0;i<index.length;i++){
  tel+=arr[index[i]];//18013820100
}
System.out.println("联系方式："+tel);

练习2：

从键盘读入学生成绩，找出最高分，并输入学生成绩等级。

成绩>=最高分-10 等级为’A'

成绩>=最高分-20 等级为’B'

成绩>=最高分-30 等级为’C'

其余 等级为‘D'

//1.使用Scanner读取学生成绩
Scanner input=new Scanner(System.in);
System.out.println("请输入学生人数：");
int number=input.nextInt();
//2.创建数组，存储学生成绩，动态初始化
int[] scores=new int[number];
//3.给数组中的元素赋值
System.out.println("请输入"+number+"个学生成绩：");
for(int i=0;i<scores.length;i++){
  score[i]=input.nextInt();
  }
}
//4.获取数组中元素的最大值：最高分
int max=0;
for(int i=0;i<scores.length;i++){
  if(max<scores[i]){
    max=scores[i];
  }
}
//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
for(int i=0;i<scores.length;i++){
  if(max-scores[i]<=10){
    lever='A';
  }else if(max-scores[i]<=20){
    lever='B';
  }else if(max-scores[i]<=30){
    lever='C';
  }else{
    lever='D';
  }
 System.out.println("student"+i+"score is"+scores[i]+",grade is"+lever); 
}

练习3：

定义数组，存放5个学生的成绩【成绩值自己设定】获得成绩之和，平均成绩，最小成绩，最大成绩。

import java.util.Scanner;

public class Text19 {
    public static void main(String[] args) {
Scanner input=new Scanner(System.in);
        int[] score=new int[5];
        int sum=0;
        for (int i = 0; i <5 ; i++) {
       System.out.println("请输入第"+(i+1)+"个人的成绩");
            score[i]=input.nextInt();
            sum=sum+score[i];
        }
System.out.println("总成绩为"+sum);
        double avg=sum/5;
System.out.println("平均成绩为"+avg);
        //获得最小成绩、最大成绩
        int max=score[0];
        int min=score[0];
        for (int a:score) {
            if (a>max){
                max=a;
            }
            if (a<min){
                min=a;
            }
        }
System.out.println("最小成绩为"+min);
System.out.println("最大成绩为"+max);
    }
}

练习4：数组的复制

1）创建一个类，在main（）方法中声明array1和array2两个变量，他们是int[]类型数组

2）使用大括号{ }，把array1初始化为8个素数：2，3，5，7，11，13，17，19

3）显示array1内容

4）赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值（如array[0]=0,array[2]=2)。打印array1。

5）实现array2对array1数组的复制

int[] array1,array2;
array1=new int{2,3,5,7,11,13,17,19};

//显示array1内容
for(int i=0;i<array1.length;i++){
  System.out.println(array1[i]+"\t");
}//2，3，5，7，11，13，17，19

//赋值array2变量等于array1
array2=array1;

//修改array2中的偶索引元素，使其等于索引值（如array[0]=0,array[2]=2)
for(int i=0;i<array2.length;i++){
  if(i%2==0){
    array2[i]=i;
  }
}

//打印array1
for(int i=0;i<array1.length;i++){
  System.out.println(array1[i]+"\t");
}//0,3,2,7,4,13,6,19

//实现array2对array1数组的复制
array2=new int[array1.length];
for(int i=0;i<array2.length;i++){
  array2[i]=array1[i];
}

练习5：数组的复制、反转、查找（线性查找、二分法查找）

String[] arr=new String{"JJ","DD","MM","BB","GG","AA"};
//数组的复制
String[] arr1=new String[arr.length];
for(int i=0;i<arr1.length;i++){
  arr1[i]=arr[i];
}

//数组的反转
//方法一：
for(int i=0;i<arr.length/2;i++){
  String temp=arr[i];
  arr[i]=arr[arr.length-1-i];
  arr[arr.length-1-i]=temp;
}
//方法二：
for(int i=0,j=arr.length-1;i<j;i++,j--){
   String temp=arr[i];
   arr[i]=arr[j];
  arr[j]=temp;
}
//遍历
for(int i=0;i<arr.length;i++){
  System.out.println(arr[i]+"\t");
}

//数组的查找
//线性查找
String dest="BB";
boolean flag=true;
for(int i=0;i<arr.length;i++){
  if(dest.equals(arr[i])){
    System.out.println("找到了指定元素位置为"+i);
    flag=false;
    break;
  }
}
if(flag){
  System.out.println("很遗憾，没有找到");
}
//二分法查找
//前提：所要查找的数组必须有序
int[] arr2=new int{-98,-34,2,34,54,66,79,105,210,333};
int daes1=-34;
int head=0;
int end=arr2.length-1;
boolean flag1=true;
while(head<=end){
  int middle=(head+end)/2;
  if(dest1==arr2[middle]){
     System.out.println("找到了指定元素位置为"+middle);
    flag1=false;
    break;
  }else if(arr2[middle]>dest1){
    end=middle-1;
  }else{
    head=middle+1;
  }
}
if(flag1){
  System.out.println("很遗憾，没有找到");
}

练习6：冒泡排序

int[] arr=new int{43,32,76,25,-98,0,64,33,-21,32,99};
for(int i=0;i<arr.length-1;i++){
  for(int j=0;j<arr.length-1-i;j++){
    if(arr[j]>arr[j+1]){
      int temp=arr[j];
      arr[j]=arr[j+1];
      arr[j+1]=temp;
    }
  }
}
for(int a:arr){
  System.out.println(a+"\t");
}

练习7：快速排序

public class Test2 {
    public static void main(String[] args) {
        int[] scores={5,8,2,1,9};
        //排序
        Arrays.sort(scores);
        for (int a:scores) {
            System.out.print(a+" ");
        }
        //查找
int i = Arrays.binarySearch(scores, 8);
        System.out.println(i);
    }
}

3.数组中常见的异常：

• 数组角标越界异常：ArraryIndexOutOfBoundsExetion

• 空指针异常：NullPointerException