慢慢懂的第五篇blog

Java学习 day05

Arrays 类

◆数组的工具类java.util.Arrays

◆由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操

作。

◆查看JDK帮助文档

◆Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是"不能")

◆具有以下常用功能:

◆给数组赋值:通过fill方法。

◆对数组排序:通过sort方法,按升序。

◆比较数组:通过equals方法比较数组中元素值是否相等。

◆查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

Arrays.toString 打印数组:

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] a= {1,2,3,4,5,6,789,45423,234,3};
        System.out.println(Arrays.toString(a));
    }
}

输出为：

Arrays.sort(a) 数组排序

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] a= {1,2,3,4,5,6,789,45423,234,3};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

输出为：

Arrays.fill 数组填充

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] a= {1,2,3,4,5,6,789,45423,234,3};
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
        int[] b= {1,2,3,4,5,6,789,45423,234,3};
        Arrays.fill(b,2,4,0);   //2<= x <4变成0
        System.out.println(Arrays.toString(b));
    }
}

输出为：

冒泡排序

两两比较，谁小谁前移

1. 比较数组中，两个相邻的元素，如果第-一个数比第二个数大，我们就交换他们的位置

2. 每一次比较。都公产生出一个最大， 或者最小的数字;

3. 下一 轮则可以少一次排序!

4. 依次循环，直到结束!

import java.util.Scanner;
import java.util.Arrays;

public class Main {
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int[] a1=new int[5];
        int n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            a1[i]=sc.nextInt();
        }
        int a[]={1,2,3,4,5,6,7,8,9,0};
        int[] sort = sour(a);
        int[] sort1 = sour(a1);
        System.out.println(Arrays.toString(sort));
        for (int i = 0; i < sort1.length; i++) {
            System.out.print(sort1[i]+" ");
        }
        System.out.println();
        System.out.println(sort1.length);
    }

    public  static int[] sour(int[] a)
    {
        int temp=0;
        for (int i = 0; i < a.length-1; i++)
            for (int j = 0; j < a.length - 1 - i; j++)
                if (a[j] < a[j + 1])
                {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
        return  a;
    }

输出为：

稀疏数组

◆当一个数组中大部分元素为0,或者为同一值的数组时，可以使用稀疏数组来保存该数组。

◆稀疏数组的处理方式是:

​ ◆记录数组-共有几行几列，有多少个不同值

​ ◆把具有不同值的元素和行列及值记录在一个小规模的数组中， 从而缩小程序的规模

◆如下图:左边是原始数组，右边是稀疏数组

public class sparsearray {
    public static void main(String[] args) {
        int[][] a =new int[11][11];
        a[1][2]=1;a[2][3]=2;
        System.out.println("输出原始数组");
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(a[i][j]!=0)
                     sum++;
            }
        }
        System.out.println("==========================================");
        int count=0;

        int[][] array=new int[sum+1][3];
        array[0][0]=11;array[0][1]=11;array[0][2]=sum;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if(a[i][j]!=0)
                {
                 count++;
                 array[count][0]=i;
                 array[count][1]=j;
                 array[count][2]=a[i][j];
                }
            }}
            for (int j = 0; j < array.length; j++) {
                System.out.println(array[j][0]+"\t"+array[j][1]+"\t"+array[j][2]);
                }
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }

}

输出为：

数组应该到这里就差不多结束了