java笔记 -- 数组

概念:

• 数组是一种数据结构, 用来存储同一类型值的集合.
• 通过一个整型的下标可以访问数组中的每一个值.
• 声明:

int[] a(推荐,将类型int[](整形数组)和变量名分开了) 或者int a[]

• 赋值:

int[] a = new int[100]; // 创建一个可以存储100个整数的数组,下标是1-99
int[] a = new int[n]; // 100可以是变量n.

• 初始化:

数字数组: 所有元素初始化为0;
boolean数组: 所有元素初始化为false;
对象数组: 所有元素初始化为null; // String[] names = new String[10];

int smallPrimes = {2, 3, 5, 7}; // 可在创建的时候直接赋值.
new int[] {1, 4, 6, 8}; // 可以初始化一个匿名数组.
smallPrimes = new int[] {1, 4, 6, 8}; // 可以在不创建新变量的时候重新初始化一个数组.

taps:
　　Java中允许数组长度为0. ---> new int[0]; // 创建新的长度为0的空数组

• 获取数组长度:

a.length;

• for each:

使用: 不需要使用下标的循环, 只关注元素本身.
for (variable : collection) statement
　　例: for (int element : a)
　　　　System.out.println(element);

• 打印数组:

1. 循环打印a[i]
2. Arrays.toString(a)
注意: 不可直接打印a, 打印出来的是地址?

• 数组拷贝:

用=赋值的新变量与原数组变量引用了同一个地址, 更改一个, 另外一个也会改变.
可以用Arrays.copyOf方法拷贝到一个新数组中:
　　int b = Arrays.copyOf(a, length);
　　length是新数组b的长度:  如果小于a.length, 只拷贝a中前length个元素.
　　　　　　　　　　　　: 如果大于a.length, 那么多余的元素会根据数组类型相应的被初始化为0 或 false, 或null

• 数组排序:

Arrays.sort(a);

数组API:

java.util.Arrays:

• static String toString(type[] a);

返回包含a中数据元素的字符串, 这个数据元素被放在括号内, 并用逗号分开.
参数a, 类型为int, long, short, char, byte, boolean, float, double的数组.

• static type copyOf(type[] a, int length)
• static type copyOf(type[] a, int start, int end)

拷贝0-length个元素或者start-end下标的元素

• static void sort(type[] a);

采用优化的快速排序算法对数组进行排序.
参数a, 类型为int, long, short, char, byte, boolean, float, double的数组.

• static int binarySearch(type[] a, type v)
• static int binarySearch(type[] a, int start, int end, type v)

用二分法搜索算法查找值v. 如果查找成功, 则返回相应的下标值; 否则, 返回一个负数值r.
-r-1是为保持a有序v应插入的位置.
参数a, 类型为int, long, short, char, byte, boolean, float, double的数组.
v 同a的数据元素类型相同的值.

• static boolean equals(type[] a, type[] b)

如果两个数组大小相同, 并且下标相同的元素都对应相等, 返回true.
参数a, b, 类型为int, long, short, char, byte, boolean, float, double的两个数组.

多维数组:
声明:
　　double[][] balance;
　　balance = new double[NYEARS][NRATES];
　　int[][] b =
　　{
　　　　{1, 2, 3,4},
　　　　{11, 22, 33,44},
　　　　{12, 23, 34,45},
　　　　{16, 27, 38,49},
　　};
　　处理多维数组需要用多层循环嵌套
　　打印多维数组:
　　1.循环打印;
　　2.Arrays.deepToString(a);

package com.picc.sample.arraysample;
import java.util.Arrays;

// 多维数组示例:
public class ArrayNote {
    public static void main(String[] args) {
        final double STARTRATE = 10;
        final int NRATES = 6;
        final int NYEARS = 10;

        double[] interestRate = new double[NRATES]; // Arrays.toString(interestRate) --> [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        for (int j = 0; j < interestRate.length; j++)
            interestRate[j] = (STARTRATE + j) / 100.0;
//        System.out.println(Arrays.toString(interestRate));

        double[][] balances = new double[NYEARS][NRATES];
//        System.out.println(Arrays.deepToString(balances));

        // set initial balances to 1000
        for (int j = 0; j < balances[0].length; j++)
            balances[0][j] = 10000;

        // compute interest for future years
        for (int i = 1; i<balances.length; i++) {
            for (int j = 0; j < balances[i].length; j++) {
                double oldBalance = balances[i - 1][j];
                double interest = oldBalance * interestRate[j];
                balances[i][j] = oldBalance + interest;
            }
        }

        for (int j = 0; j < interestRate.length; j++)
            System.out.printf("%9.0f%%", 100 * interestRate[j]);

        System.out.println();
        for (double[] row : balances) {
            for (double b : row)
                System.out.printf("%10.2f", b);
            System.out.println();
        }
    }
}

运行结果:

　　10% 　　11% 　　  12% 　　　13% 　　 14% 　　　　15%
10000.00 10000.00 10000.00 10000.00 10000.00 10000.00
11000.00 11100.00 11200.00 11300.00 11400.00 11500.00
12100.00 12321.00 12544.00 12769.00 12996.00 13225.00
13310.00 13676.31 14049.28 14428.97 14815.44 15208.75
14641.00 15180.70 15735.19 16304.74 16889.60 17490.06
16105.10 16850.58 17623.42 18424.35 19254.15 20113.57
17715.61 18704.15 19738.23 20819.52 21949.73 23130.61
19487.17 20761.60 22106.81 23526.05 25022.69 26600.20
21435.89 23045.38 24759.63 26584.44 28525.86 30590.23
23579.48 25580.37 27730.79 30040.42 32519.49 35178.76

package com.picc.sample.arraysample;

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

// 输出输出, 数组方法
public class LotterDrawing {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        System.out.println("How many numbers do you need to draw");
        int k = in.nextInt();

        System.out.println("How many numbers do you need to draw");
        int n = in.nextInt();

        int[] numbers = new int[n];
        for (int i = 0; i < numbers.length; i++)
            numbers[i] = i + 1;

        int[] result = new int[k];

        for (int i = 0; i < result.length; i++) {
            int r= (int) (Math.random() * n);
            result[i] = numbers[r];
            numbers[r] = numbers[n - 1];
            n--;
        }

        Arrays.sort(result);

        // 两种打印方法
//        System.out.println(Arrays.toString(result));
        for (int r: result)
            System.out.print(r + ", ");
    }
}

运行示例:

How many numbers do you need to draw

How many numbers do you need to draw

1, 4, 5, 9, 13,