JAVA 배열 사용 설명

JAVA 수조와 용기류는 주로 세 가지 차이가 있는데 그것이 바로 효율, 유형과 기본 유형을 보존하는 능력이다.JAVA에서 배열은 가장 효율적인 저장 및 무작위 접근 대상 인용 시퀀스 방식이다.수조는 간단한 선형 수열로 원소의 접근이 매우 빠르다.그러나 이 때문에 대가를 치르는 것은 수조의 크기가 고정되고 생명주기에서 바꿀 수 없는 것이다.모델과 자동 포장 메커니즘의 출현으로 용기는 이미 수조와 거의 똑같이 기본 유형에 편리하게 사용할 수 있게 되었다.수조와 용기는 어느 정도 당신이 그들을 남용하는 것을 방지할 수 있습니다. 경계를 넘으면 Runtime Exception 이상을 얻을 수 있습니다.수조의 열매가 존재하는 장점은 효율이다. 그러나 더욱 일반화된 문제를 해결하려면 수조가 너무 많은 제한을 받을 수 있기 때문에 이런 상황에서 대부분은 용기를 선택한다.따라서 최근 JAVA 버전을 사용할 경우 배열이 아닌 컨테이너를 우선적으로 선택해야 합니다.성능이 문제가 되고 수조로 전환하면 성능을 향상시킬 수 있다는 것이 증명되었을 때만 프로그램을 수조로 재구성해야 한다.[초기화] JAVA는 수조 초기화에 대해 매우 엄격한 규정을 가지고 있어 수조의 남용을 효과적으로 방지할 수 있다.초기화 오류가 발생하면 Runtime Exception 대신 Compile Exception 을 받게 됩니다.수조를 정확하게 초기화하기 전에 이 수조로 인용할 수 없습니다.수조 정의는 int[]array와 intarray[]가 있는데 일반적으로 첫 번째 스타일을 채택하여 유형과 변수 이름을 분리할 수 있다.수조의 초기화는 정적 초기화와 동적 초기화 두 가지 방식이 있다.초기화할 때 반드시 길이를 지정해야 하며, 다차원수 그룹의 1차원 길이는 반드시 지적해야 하며, 동시에 반드시 고차원에서 저차원으로 정의해야 한다.초기화 동작은 코드의 어느 곳에서든 나타날 수 있지만, ｛｝ 방식은 그룹을 만드는 곳에서만 나타날 수 있습니다.구체적인 초기화 방식은 프로그램 참조:

public class javaArrayInit{
    public static void main(String args[]){
        int[] arrayA; // 
        int[] arrayB = new int[5]; // 
        //System.out.println(arrayA.length);  //CompileException
        System.out.println("arrayB length: " + arrayB.length); // 

        arrayA = new int[10]; // 
        System.out.println("arrayA length: " + arrayA.length);

        int[] arrayC = new int[]{1,2,3,4};
        System.out.println("arrayC length: " + arrayC.length);

        //int[] arrayD = new int[1]{1}; // ， 

        int[][] arrayE = new int[1][];
        System.out.println("arrayE length: " + arrayE.length);

        //int[][] arrayF = new int[][2]; // 

        int[][] arrayG = new int[][]{{1,2,3,4},{5,6,7},{7,24,23,24}};
        System.out.println("arrayG length: " + arrayG.length);

        int[][][] arrayH = new int[][][]{{{1,2,3},{4,5,6},{7,8,9},{10,11,12}}};
        System.out.println("arrayH length: " + arrayH.length);

        dummyArray[] arrayI = {new dummyArray(),new dummyArray()}; // 
        System.out.println("arrayI length: " + arrayI.length);
        System.out.println("arrayI[1]: " + arrayI[1].getValue());

        dummyArray[] arrayK = new dummyArray[5];
        System.out.println("arrayK[0]: " + arrayK[0]); //null
        for(int i = 0; i < arrayK.length; i++){
            arrayK[i] = new dummyArray();
        }
        System.out.println("arrayK[0]: " + arrayK[0].getValue()); //2
    }
}
class dummyArray{
    private static int temp;
    private final int arrayValue = temp++;
    public int getValue(){
        return arrayValue;
    }
}
 ：
arrayB length: 5
arrayA length: 10
arrayC length: 4
arrayE length: 1
arrayG length: 3
arrayH length: 1
arrayI length: 2
arrayI[1]: 1
arrayK[0]: null
arrayK[0]: 2

[length] 구성원만 읽는 length는 수조 대상의 일부분(실제 API에는 이 변수가 설명되어 있지 않지만 실행할 때 동적 생성)이다. 이것은 유일하게 접근할 수 있는 필드나 방법이다.한편, [] 문법은 그룹 대상에 접근하는 유일한 방법이며, 용기는 get () 방법을 통해 접근한다.Array를 사용할 수 있습니다.length는 수조의 크기를 얻을 수 있습니다. String 유형의 String에 주의하십시오.length () 구분.Array는 구성원 변수를 사용하고 String은 구성원 방법을 사용합니다.동시에, Array.length는 수조의 크기만 얻을 수 있을 뿐, 수조의 실제 원소가 얼마나 있는지 얻을 수 없습니다.다차원수 그룹의length는 1차원의 길이만 계산합니다.

public class javaArrayLength{
    public static void main(String args[]){
        int[] arrayA = new int[15];
        arrayA[1] = 1;
        arrayA[2] = 2;
        arrayA[3] = 3;
        System.out.println("arrayA length: " + arrayA.length);

        int[][] arrayB = new int[10][];
        System.out.println("arrayB length: " + arrayB.length);

        int[][] arrayC = new int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7},};// 
        System.out.println("arrayC length: " + arrayC.length);

        int[][] arrayD = new int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7},{}};
        System.out.println("arrayD length: " + arrayD.length);
    }
}
 ：
arrayA length: 15
arrayB length: 10
arrayC length: 3
arrayD length: 4

【Arrays.fill】Arrays.fill은 여러 위치를 같은 값으로만 채울 수 있기 때문에 매우 제한된 작용을 합니다. (대상이라면 같은 인용을 복사해서 채울 수 있습니다.)Arrays를 사용합니다.fill은 전체 수조나 수조의 특정한 구역을 채울 수 있지만, 단일한 수치로만 Arrays를 호출할 수 있기 때문입니다.fill, 그래서 작용이 크지 않습니다.[값 부여와 인용] JAVA 수조를 초기화할 때 가진 것은 수조에 대한 인용일 뿐 수조에 저장 공간을 분배하지 않았다.따라서 수조 간의 복사는 같은 대상을 조작하기 때문에'='로 간단하게 값을 부여할 수 없다.다음 절차:

public class javaArrayQuote{
    public static void main(String args[]){
        String testA = "testA";
        String testB = "testB";
        String[] arrayA = new String[]{"arrayA"};
        String[] arrayB = new String[]{"arrayB"};
        testB = testA;
        testB = "testB change";
        System.out.println("I'm testA,I have no changed: " + testA);
        arrayB = arrayA;
        arrayB[0] = "arrayB have changed";
        System.out.println("I'm arrayA, I have no changed: " + arrayA[0]);

    }
}
 ：
I'm testA,I have no changed:testA
I'm arrayA, I have no changed:arrayB have changed

알 수 있듯이 우리는arrayB[0]의 값을 바꾸고 인용된 수조를 바꾸었기 때문에 우리는arrayA[0]를 출력하는데 사실은arrayB[0]와 같다.[배열 복사] JAVA에서 배열을 복사하는 방법: 1.FOR 루프를 사용하여 전체 또는 지정된 요소를 복사하여 효율성이 낮음 2.clone 방법을 사용하여 인용이 아닌 그룹의 값을 얻습니다.그러나clone은 지정된 요소를 복사할 수 없습니다. 유연성이 낮습니다.시스템 사용.arraycopy(src, srcPos,dest,destPos,length) 방법,java 표준 라이브러리는 static 방법 시스템을 제공합니다.arraycopy (), 그것으로 수조를 복제하는 것이 for 순환보다 훨씬 빠르다, 시스템.arraycopy () 는 모든 형식을 다시 불러옵니다. 기본 형식 그룹과 대상 그룹은 모두 System을 사용할 수 있습니다.arraycopy () 복제, 그러나 대상 수조는 복사 인용일 뿐, 두 개의 대상 복사가 나타나지 않습니다.이것은 얕은 복사(shallowcopy)라고 불린다.src: 원본 그룹;srcPos: 원본 그룹이 복사할 시작 위치;dest: 목적 그룹;destPos: 목적 배열 배치의 시작 위치;length: 복사된 길이입니다.참고: 시스템.arraycopy () 는 자동 포장과 자동 포장을 하지 않기 때문에 두 개의 수조는 반드시 같은 유형이거나 같은 유형의 수조로 전환할 수 있어야 한다.이 방법은 그룹 자체를 복제하는 데도 쓰일 수 있다.        int[] test ={0,1,2,3,4,5,6};        System.arraycopy(test,0,test,3,3);결과는 {0, 1, 2, 0, 1, 2, 6}이다.테스트 프로그램은 다음과 같습니다

public class javaArrayCopy{
    public static void main(String args[]){
        int[] array = {1,2,3,4,5,6,7,8,9};
        //for 
        int[] arrayA = new int[9];
        for(int i = 0; i < arrayA.length; i++){
            arrayA[i] = array[i];
            System.out.print(arrayA[i] + ",");
        }
        // 
        System.out.println("");
        arrayA[1] = 19;
        for(int i = 0; i < arrayA.length; i++){
            System.out.print(arrayA[i] + ",");
        }
        System.out.println("");
        for(int i = 0; i < array.length; i++){
            System.out.print(array[i] + ",");
        }
        System.out.println("");

        //clone 
        int[] arrayB = new int[9];
        arrayB = array.clone();
        // 
        arrayB[1] = 19;
        for(int i = 0; i < arrayB.length; i++){
            System.out.print(arrayB[i] + ",");
        }
        System.out.println("");
        for(int i = 0; i < array.length; i++){
            System.out.print(array[i] + ",");
        }
        System.out.println("");

        //System.arrayCopy  
        int[] arrayC = new int[9];
        System.arraycopy(array, 0, arrayC, 0, arrayC.length);
        // 
        arrayC[1] = 19;
        for(int i = 0; i < arrayC.length; i++){
            System.out.print(arrayC[i] + ",");
        }
        System.out.println("");
        for(int i = 0; i < array.length; i++){
            System.out.print(array[i] + ",");
        }
    }
}

[수조 비교] Arrays는 재부팅 후의 equals() 방법을 제공하여 모든 유형과 Object 유형에 대해 재부팅을 하여 전체 수조를 비교한다.수조가 같은 조건은 원소의 개수가 반드시 같고 대응하는 위치의 원소도 같다는 것이다.다차원 그룹의 비교는 deepequals() 방법을 사용한다.Array.equals () 방법을 비교한 두 그룹은 반드시 같은 유형의 그룹이어야 한다..

import java.util.Arrays;
public class javaArrayEquals{
    public static void main(String args[]){
        int[] arrayA = {1,2,3};
        int[] arrayB = {1,2,3,};
        int[] arrayC = new int[4]; //if int[] arrayC = new int[3],return true
        arrayC[0] = 1;
        arrayC[1] = 2;
        arrayC[2] = 3;
        System.out.println(Arrays.equals(arrayA, arrayB));
        System.out.println(Arrays.equals(arrayA, arrayC));

        String[][] arrayD = {{"a","b"},{"c","d"}};
        String[][] arrayE = {{"a","b"},{"c","d"}};
        System.out.println(Arrays.deepEquals(arrayD, arrayE));
    }
}

[수조 정렬과 찾기] 수조는 내장된 정렬 방법sort()를 제공하여 임의의 기본 유형의 수조나 대상의 수조를 정렬할 수 있다(이 대상은 Comparable 인터페이스나 관련된Comparator를 실현해야 한다).JAVA는 서로 다른 유형에 대해 서로 다른 정렬 방법을 제공했다. - 기본 유형에 대한 빠른 정렬과 대상에 대한 디자인의'안정적인 병합 정렬'이기 때문에 수조 정렬의 효율 문제를 걱정할 필요가 없다.binarySearch () 는 정렬된 수조에서 요소를 신속하게 찾는 데 사용되며, 정렬되지 않은 수조에 binarySearch () 를 사용하면 예측하기 어려운 결과가 발생합니다.[반환수조] C와 C++는 하나의 수조를 되돌릴 수 없고 지향수조를 가리키는 바늘만 되돌릴 수 있습니다. 왜냐하면 반환수조는 수조의 생명주기를 제어하기 어렵고 메모리 유출을 초래하기 쉽기 때문입니다.java는 하나의 그룹을 직접 되돌릴 수 있고 쓰레기 회수 메커니즘으로 회수할 수 있습니다.[수조와 용기 변환] [기본 형식 수조를 변환할 수 없음] 수조를List:

import java.util.*;
public class arrayToList{
    public static void main(String args[]){
        String[] arrayA = {"a","b","c"}; 
        List listA = java.util.Arrays.asList(arrayA);
        System.out.println("listA: " + listA);

        int[] arrayB = {1,2,3}; 
        List listB = java.util.Arrays.asList(arrayB);
        System.out.println("listB: " + listB);

        Integer[] arrayC = {1,2,3};
        List listC = java.util.Arrays.asList(arrayC);
        System.out.println("listC: " + listC);
    }
}
 ：

listA: [a, b, c]
listB: [[I@de6ced]
listC: [1, 2, 3]

왜 int와 Integer의 출력은 다릅니까?목록이 그룹으로 바뀝니다

import java.util.*;
public class listToArray{
    public static void main(String args[]){
        List<String> list = new ArrayList<String>();
        String[] array;
        list.add("testA");
        list.add("testB");
        list.add("testC");
        System.out.println("list: " + list);

        String[] strings = new String[list.size()];
        array = list.toArray(strings);
        for(int i = 0, j = array.length; i < j; i++){
            System.out.print(array[i] + ",");
        }
    }
}
 ：
list: [testA, testB, testC]
testA,testB,testC

[중복 데이터 제거] 수조와 용기 변환을 이용하여 수조의 중복 데이터를 편리하게 제거할 수 있지만 수조가 너무 크면 효율이 문제입니다..

import java.util.*;
public class javaArrayUnique{
    public static void main(String args[]){
        String[] array = {"a","b","a","a","c","b"};
        arrayUnique(array);
        //test
        for(int i = 0, j = arrayUnique(array).length; i < j; i++){
            System.out.print(arrayUnique(array)[i] + ",");
        }
    }

    public static String[] arrayUnique(String[] array){
        List<String> list = new ArrayList<String>();
        for(int i = 0, j = array.length; i < j; i++){
            if(!list.contains(array[i])){
                list.add(array[i]);
            }
        }
        String[] strings = new String[list.size()];
        String[] arrayUnique = list.toArray(strings);
        return arrayUnique;
    }
}

효율 문제에 대해 나는 비교를 했다. 내 컴퓨터에서 10만 개의 데이터를 실행하는 수조는 대략 577ms이고 100만 개의 데이터를 실행하는 데이터는 대략 5663ms이다.이것은 또한 컴퓨터의 운행 능력과 관계가 있지만, 분명히 수조의 크기에 따라 점차적으로 증가한다

import java.util.*;
public class javaArrayUnique{
    public static void main(String args[]){
        Double[] array = new Double[100000];
        for(int i = 0, j = array.length; i < j; i++){
            array[i] = Math.ceil(Math.random()*1000);
        }

        Double[] arrayB = new Double[1000000];
        for(int i = 0, j = arrayB.length; i < j; i++){
            arrayB[i] = Math.ceil(Math.random()*1000);
        }

        System.out.println("start");
        long startTime = System.currentTimeMillis();
        arrayUnique(array);
        long endTime = System.currentTimeMillis();
        System.out.println("array unique run time: " +(endTime - startTime) +"ms");

        long startTimeB = System.currentTimeMillis();
        arrayUnique(arrayB);
        long endTimeB = System.currentTimeMillis();
        System.out.println("arrayB unique run time: " +(endTimeB - startTimeB) +"ms");
    }

    public static Double[] arrayUnique(Double[] array){
        List<Double> list = new ArrayList<Double>();
        for(int i = 0, j = array.length; i < j; i++){
            if(!list.contains(array[i])){
                list.add(array[i]);
            }
        }
        Double[] doubles = new Double[list.size()];
        Double[] arrayUnique = list.toArray(doubles);
        return arrayUnique;
    }
}
 ：
start
array unique run time: 577ms
arrayB unique run time: 5663ms