数组属性的习题、Arrays工具、二维数组

一、数组的练习

　　1.声明一个char类型的数组， 从键盘录入6个字符: 【1】遍历输出 【2】排序 【3】把char数组转化成一个逆序的数组。

 import java.util.Scanner;
 public class Operation01{
     public static void main (String[] args){
         char[] zifu = new char[6];
         Scanner car = new Scanner(System.in);
         char temp;
         //从键盘上获取字符存放于数组中，并输出
         for(int i=0;i <zifu.length;i++){
             System.out.println("请输入第"+(i+1)+"个字符");
             zifu[i] = car.next().charAt(0);

         }
         for(int i=0;i <zifu.length;i++){
         System.out.print(zifu[i]+"\t");
         }
         //按照冒泡法排的序列
         for(int i = 1;i < zifu.length;i++){
             for(int j =0;j < zifu.length-i;j++){
                 if(zifu[j] >zifu[j+1]){
                     temp = zifu[j];
                     zifu[j] =zifu[j+1];
                     zifu[j+1] = temp;

                 }
             }
         }
         System.out.println();
         for(int i=0;i <zifu.length;i++){
             System.out.print(zifu[i]+"\t");
         }
         //实现逆序输出
         int a =zifu.length/2;
         for(int i=0;i < a;i++){
             temp = zifu[i];
             zifu[i] = zifu[zifu.length-1-i];
             zifu[zifu.length-1-i] =temp;
         }
         System.out.println();
         for(int i=0;i <zifu.length;i++){
             System.out.print(zifu[i]+"\t");
         }

     }
 }

　　2.有一组数分别为18,25,7,36,13,2,89,63求出最小的值,并将最小的数与最小的数所在的下标输出。

 public class Operation03{
     public static void main (String[] args){
         int[] arr ={18,25,7,36,13,2,89,63};
         /*定义一个int变量min，把数组第1个元素
         赋值给其，让min依次和数组后面的元素比较，
         如果min比后面的元素大，则把这个元素的值付给它
         否则依然是min等于数组第一个元素*/
         int min =arr[0];
         int loc = 0;
         for(int i = 1;i <arr.length;i++){
             if(min > arr[i]){
                 min = arr[i];
                 loc = i;
             }
         }

         System.out.println("最小的值为："+min+"下标"+loc);
     }
 }

　　

　　3.已知一个数组存在重复元素，请去掉数组中的重复元素。

 public class Operation07{
     public static void main (String[] args){
         int[] arr ={1,1,1,6,3,4,5,0,0};
         int len = arr.length;
         int cop;
         for(int i = 0;i <len;i++){
             cop =arr[i];

             for(int j = i+1;j < len;j++){

                 if(cop == arr[j]){
                     //移动
                     for(int k =j;k <len-1;k++){
                         arr[k] = arr[k+1];
                     }
                     //移动完成后在末尾补0,并该变每一轮循环的次数
                     arr[len-1] = 0;
                         j--;
                         len--;
                 }
             }
         }
         //为区分是否已删除末尾的0，遍历数组显示到len
         for(int i = 0;i <len;i++){
             System.out.print(arr[i]+"\t");
         }
     }
 }

二、  命令行参数（C）

　　在程序运行过程中，可以向应用程序传递一些参数，这些参数称为命名行参数。

 public class Test03{
     public static void main (String[] args){
     //获取字符串，保存于args[]中，并统计字符串的个数
         System.out.println(args.length);
         for(int i = 0;i < args.length;i++){
             System.out.println(args[i]);
         }
     }
 }

　　命令行参数以字符串的形式传入args数组中。可以一次传递0-多个参数，以空格分割。

　　如果参数中本身包含空格，需要使用引号引起来。

三、Arrays类
　　jdk中为了便于开发，给开发者提供了Arrays，其中包含了很多数组的常用操作，例如：快速输出、排序、查找等。

　　常用方法

 import java.util.Arrays;
 public class Test04{
     public static void main (String[] args){
         int[] arr = {1,3,4,6,2,7};
         // 【1】数组的字符串形式
         System.out.println(Arrays.toString(arr));

         //【2】sort对数组排序(只能升序)-> 内部使用快速排序。
         Arrays.sort(arr);
         System.out.println(Arrays.toString(arr));

         //全部填充num,fill（arr,num）;
         //Arrays.fill(arr,0);
         //System.out.println(Arrays.toString(arr));
         /*
             判断两个数组是否相等
             equals(arr1,arr2);
             数组相等的条件:1.长度相等 2.对应位置元素相等。
           */
         int[] arr2 = {1,3,4,6,2,7};
         System.out.println(Arrays.equals(arr,arr2));
     }
 }

　　二分法查找

 private static int binarySearch0(long[] a, int fromIndex, int toIndex,
                                      long key) {
         int low = fromIndex;
         int high = toIndex - 1;

         while (low <= high) {
             int mid = (low + high) >>> 1;
             long midVal = a[mid];
 if (midVal < key)
                 low = mid + 1;
             else if (midVal > key)
                 high = mid - 1;
             else
                 return mid; // key found
         }
         return -(low + 1);  // key not found.
     }

　　二分法查找的必须是有序的数组，如果找到返回索引；如果没有找到，返回-插入点-1。插入点就是key应该放到数组的位置。

数组的复制

　　copyOf(arr,len) 把arr复制len个长度的元素并返回新数组。如果len>arr.length,新数组的长度末尾用0填充。

　　copyOfRange(arr,from,to) 从arr中from(包含)位置开始复制到to(不包含)这个范围的元素到新数组中。含头不含尾。

 import java.util.Arrays;
 public class Test01{
     public static void main (String[] args){
         int[] arr = {1,3,4,6,2,7};
         //copyOf(arr,length)
         int[] newArr = Arrays.copyOf(arr,5);
         System.out.println(Arrays.toString(newArr));
         //copyOfRange(arr,form,to)
         int[] newArr2 = Arrays.copyOfRange(arr,1,4);
         System.out.println(Arrays.toString(newArr2));
         }
 }

　　System也提供了赋值数组的方法。

　　　　arraycopy(srcArr,srcPos,destArr,destPos,len)

　　　　srcArr:要复制的源数组；srcPos:从srcArr的srcPos位置开始复制；destArr:复制到的目标数组；destPos:目标数组从destPos开始存放；

　　　　len:从源数组中复制len个长度

int[] arr2 = new int[5];
        System.arraycopy(arr,2,arr2,1,4);
        System.out.println(Arrays.toString(arr2));

四、二维数组

二维数组就是数组的数组，数组的元素也是数组。

二维数组表示二维的行列结构

二维数组的声明

 import java.util.Arrays;
 public class Test05{
     public static void main(String[] args){

         // 二维数组
         //int[]
         // (int[]) []

         // 【1】声明
         int[][] arr;
         // 【2】初始化一个能存3个一维数组的二维数组
         arr = new int[3][];

         // 【3】赋值
         int[] arr1 = {1,3,4,5};
         int[] arr2 = {1,3,4};
         int[] arr3 = {2,1,6,4};

         arr[0] = arr1;
         arr[1] = arr2;
         arr[2] = arr3;

         System.out.println(arr);
         System.out.println(Arrays.toString(arr));
     }
 }

此时arr = new int[3][];只分配了二维数组的空间，一维数组没有分配空间。

声明一个规则的二维数组

import java.util.Arrays;
public class Test06{
    public static void main(String[] args){

        // 声明一个规则的二维数组，3行4列
        int[][] arr;
        arr = new int[3][4];
arr[0][0] = 10;
        arr[0][1] = 20;
        arr[0][2] = 30;
        arr[0][3] = 40;

        arr[1][0] = 100;
        arr[1][1] = 200;
        arr[1][2] = 300;
        arr[1][3] = 400;

        arr[2][0] = 1000;
        arr[2][1] = 2000;
        arr[2][2] = 3000;
        arr[2][3] = 4000;

        System.out.println(Arrays.toString(arr));
    }
}

此时，二维数组已经分配好空间，同时一维也分配好空间。

当已知二维数组的值数，可以考虑字面量声明

import java.util.Arrays;
public class Test07{
    public static void main(String[] args){

        // 声明字面量二维数组
        int[][] arr = {
            {10,20,30,40},
            {100,200,300},
            {1000,2000,3000,4000}
        };
        System.out.println(Arrays.toString(arr));
    }
}

 

  二维数组的遍历

import java.util.Arrays;
public class Test02{
    public static void main (String[] args){
        int[][] arr = {
            {10,20,30},
            {100,200,300,400},
            {1000,2000,3000}
        };
         /*
        int[] temp;
        for(int i=0;i <arr.length;i++){
             temp = arr[i];
            for(int j=0;j < temp.length;j++){
                System.out.print(temp[j]+"\t");
            }
            System.out.println();
        }
        */
        for(int i = 0;i < arr.length;i++){
            for(int j = 0;j < arr[i].length;j++){
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

五、基本数据类型和引用数据类型赋值的区别

基本数据类型赋值时，复制的是值

引用数据类型赋值时，复制的是引用。

public class Test09{
    public static void main(String[] args){

        // 基本数据类型的赋值
        int a = 10;
        int b;
        b = a;
        // a? b?
        b = 20;
        // a? b?

        // 引用数据类型的赋值
        int[] arr = {1,3,5};
        int[] arr2 = arr;
        arr2[0] = 100;

        System.out.println("arr:"+arr);
        System.out.println("arr2:"+arr2);

        System.out.println("arr[0]:"+arr[0]);

    }
}