java_数组

1、eclipse输入提示：Alt+/

数组的声明

1、静态初始化

int arr[] =new int[]{3,9,8};
int[] arr = {3,9,8};

2、动态初始化

int [] arr = new int[3]

数组小知识

1、长度：每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
2、随机数：在[a,b]内取随机数。(Math.random*(b-a+1)+a)
Math.random()默认产生大于等于0.0且小于1.0之间的随机double型随机数
即：0.0<=Math.random()<1.0

多维数组

练习题

练习2

public class ArrayExer1{
        public static main(String[] args)
    {
            int [][]arr= new int [][]{{3,5,8},{12,9},{7,0,6,4}};
        int sum=0;
        for(int i=0;i<arr.length ;i++)
        {
            for(int j=0;j<arr[i].length;j++){
                  sum+=arr[i][j];
          }
        }
        System.out.println("总和为："+sum );
    }
}

练习3

练习4

public class YangHuiTest{
    public static void main(String[] args){
      //声明并初始化
      int[][] yanghui=new int[10][];
    //给数组的元素赋值
    for(int i=0;i<yanghui.length;i++){
        yanghui[i]=new int[i+1];
      //2.1给首末元素赋值
      yanghui[i][0]=1;
      yanghui[i][i]=1;
      //给每行的非首末元素进行赋值
      if(i>1){
          for(int j=1;j<yanghui[i].length-1;j++){
            yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
        }
      }
    }
    //遍历数组
    for(int i;i<yanghui.length;i++){
        for(int j=0;j<yanghui[i].length;j++){
          System.out.print(yanghui[i][j]+" ");//不换行
      }
      System.out.println();//换行
    }
  }
}

拓展笔试题

创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。

public class tuozhan{
    public static void main(String[] args){
        //声明数组
        int[] num=int[6];
        //赋值并判断
        for(int i=0;i<6;i++){
            //num[i]=(Math.random*(30)+1);
            num[i]=(Math.random()*30+1);
            for(int j=0;j<i;j++){
                if(num[i]==num[j])
                {
                    i=i-1;
                    break;
                }
            }
        }
     //数组打印
        for(int k=0;k<num.length();k++)
            System.out.print(num[k]+",");
    }
}

数组中常见的算法

数组元素的赋值(杨辉三角、回形数等)

回形数：从键盘输入一个整数（1~20） 则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。

import java.util.Scanner;
public class hui{
    public static void main(String[] args){
        //2.Scanner的实例化
        Scanner scan = new Scanner(System.in);
        //接受数据
        System.out.println("请输入1-20的整数：");
        int n = scan.nextInt();
        //System.out.println(age);
    }
}

求数值型数组中元素的最大值、最小值、平均数、总和等

练习5

public class ArrayExer1 {
    public static void main(String[] args) {
        //int[] num=num[10];
        int []num = new int[10];
        for(int i=0;i<num.length;i++){
            num[i]= Math.random()*90+10;
        }
        //最大值
        //
        System.out.println("总和为：" + sum);
    }
}

数组的复制、反转、查找(线性查找、二分法查找)

数组的复制

练习6

public class ArrayTest {//自己写的
    public static void main(String[] args) {
        //初始化
        //int [] array1 = new int{2,3,5,7,11,13,17,19};
        int [] array1 = new int[]{2,3,5,7,11,13,17,19};
        int [] array2 = new int[array1.length];//为array2创建空间
        //int [] array2;//只是声明
        //显示Array1的内容
        for(int i;i<array1.length;i++){
            System.out.println(array1[i]);
            array2[i]=array1[i];//赋值array2
        }
       // array2=array1;
        //修改array2
        for(int j=0;j<array2.length;j=j+2){
            array[j]=j;
        }  
    }
}

 * 使用简单数组
(1)创建一个名为ArrayExer2的类，在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。
 * 
 * 思考：array1和array2是什么关系？array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。
 * 拓展：修改题目，实现array2对array1数组的复制
 */
public class ArrayExer2 {//参考答案
    public static void main(String[] args) {  //alt + /
        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.print(array1[i] + "\t");
        }
        //赋值array2变量等于array1
        //不能称作数组的复制。
        array2 = array1;
        //老师在ArrayExer2
        //修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
        for(int i = 0;i < array2.length;i++){
            if(i % 2 == 0){
                array2[i] = i;
            }
        }
        System.out.println();
        //打印出array1
        for(int i = 0;i < array1.length;i++){
            System.out.print(array1[i] + "\t");
        }
    }
}

数组的反转

public class Array{
    public static void main(String[] args){
        String[] arr = new string[]{"11","22","33","44","55","66"};
        //数组的反转
        for(int i=0;i<arr.length/2;i++){
            String temp = arr[i];
            arr[i]=arr[arr.length-i-1];
            arr[arr.length-i-1]=temp;
        }
        //遍历
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]+"\t");
        }    
    }
}

线性查找

判断

public class Array{
    public static void main(String[] args){
        String[] arr = new string[]{"11","22","33","44","55","66"};
        //
        String dest = "33";
       // bool flag =false;
        boolean isFlag=true;
        for(int i=0;i<arr.length;i++){
            if(dest.equals(arr[i])){
                isFlag=false;
                 System.out.println("找到了指定的位置:"+i);
                break;
            }
        }
        if(isFlag){
            System.out.println("很遗憾，未找到！");
        }
    }
}

二分查找(考察频繁)

public class Array{
    public static void main(String[] args){
        //二分法查找：(熟悉)
        //前提：所要查找的数组必须有序。
        int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int dest1 = -34;
        int head =0;
        int end = arr2.length-1;
        boolean isFlag=true;
        while(head<=end){
            int mid=(head+end)/2;
            if(dest1=arr2[mid]){
                System.out.println("找到了指定的位置:"+mid);
                isFlag=false;
                break;
            }
            else if(dest<arr2[mid]){
                //end=mid;这个是错误的
                end=mid-1;
            }
            else{
                //head=mid;这个是错误的
                head=mid+1;
            }
        }
        if(isFlag){
            System.out.println("很遗憾，未找到！");
        }
    }
}

数组元素的排序算法

要求：红色部分必须会手写，黄色的需要知道思想

冒泡排序（会手写）

public class BubbleSortTest{
    public static void main(String[] args){
        int[] arr = new int[]{45,84,3,7,56,23,48,58,58};
        //冒泡排序
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int temp =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        //遍历输出
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
    }
}

快速排序（会手写）

Arrays工具类

import java.util.Arrays;
/*
 * java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
 * 
 * 
 */
public class ArraysTest {
    public static void main(String[] args) {
        //1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
        int[] arr1 = new int[]{1,2,3,4};
        int[] arr2 = new int[]{1,3,2,4};
        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);
        //2.String toString(int[] a):输出数组信息。
        System.out.println(Arrays.toString(arr1));
        //3.void fill(int[] a,int val):将指定值填充到数组之中。
        Arrays.fill(arr1,10);
        System.out.println(Arrays.toString(arr1));
        //4.void sort(int[] a):对数组进行排序。
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));
        //5.int binarySearch(int[] a,int key)
        int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int index = Arrays.binarySearch(arr3, 210);
        if(index >= 0){
            System.out.println(index);
        }else{
            System.out.println("未找到");
        }
    }
}