일반적으로 교과서의 데이터 구조에는 배열, 단일 링크 목록, 스택, 트리 및 그래프가 포함됩니다. 여기서 언급하는 데이터 구조는 객체를 나타내는 방법에 대한 질문입니다. 때로는 int, String, Double 또는 1 차원 배열 및 2 차원 배열과 같은 단일 변수 선언이 쓸모가 없으며, 표현하려는 것을 완전히 표현할 수 없으며 클래스 클래스를 정의하기에는 너무 번거 롭습니다. 현재 Java의 컬렉션 클래스 사용을 고려할 수 있습니다. 컬렉션 클래스를 사용하면 import java.util을 선언해야합니다.* 파일 헤더에서;
1. 동적, 순서, 가변 크기의 1 차원 배열 벡터 및 Arraylist
컬렉션 클래스 에는 동적, 순서대로 가변 크기의 1 차원 배열 벡터 및 Arraylist가 포함됩니다.
벡터와 Arraylist의 유일한 차이점은 다음과 같습니다. 벡터는 스레드가 서로 배타적으로 제공되며 여러 스레드는 읽고 쓰는 것으로 예외를 던지고 ArrayList는 여러 스레드가 읽고 쓸 수 있으며 다른 부분은 정확히 동일합니다. 다시 말해, 단일 스레드가 읽고 쓰는 경우 벡터와 Arraylist 사용 사이에는 차이가 없지만 이제는 프로그래밍이 기본적으로 Arraylist이며 벡터를 사용하는 것은 비 임원입니다.
1. 벡터의 사용은 다음과 같습니다.
public static void vectortest () {// vector <double>은이 벡터 만 더블 // 벡터 <문자열도 저장할 수 있음을 의미합니다. 벡터 벡터 = new // 벡터 ()와 동일합니다. 그러나이를 일식에 작성하면 벡터가 표준화되지 않았 음을 나타냅니다. vector.add (1.6); vector.add (2.06); vector.add (1); System.out.println ( "간단한 추가는 끝에서 요소를 추가하는 수단 :" + 벡터); System.out.println ( "size ()는 벡터에 포함 된 요소의 수를 찾을 수 있습니다 :" + vector.size ()); vector.remove (1); System.out.println ( "제거 (1)는 카운트가 0에서 시작하기 때문에 첫 번째 요소를 삭제하는 것을 의미합니다. 즉, 요소 2.06 :" + 벡터); vector.remove (vector.lasteLement ()); System.out.println ( "마지막 요소를 삭제하는 벡터는" + 벡터); vector.add (0, 1.8888); System.out.println ( "1.8888 추가이 요소는 0 번째 위치에 있습니다." + 벡터); vector.set (0, "a"); System.out.println ( "0 번째 위치 변경 :" + 벡터); } 이 메소드가 주요 함수에서 호출되는 경우 :
System.out.println ( "======== 벡터 데이터 구조의 시작 ==========="); vectortest (); System.out.println ( "========= 벡터 데이터 구조의 테스트 종료 ===============);
작업 결과는 다음과 같습니다.
======= 벡터 데이터 구조의 시작 테스트 ======
간단한 추가는 끝에서 요소를 추가하는 것을 의미합니다. [1.6, 2.06, 1]
크기 () 벡터에 포함 된 요소 수를 찾을 수 있습니다 : 3
제거 (1)는 첫 번째 요소를 삭제하는 것을 의미합니다. 카운트는 0에서 시작하기 때문에 요소 2.06 : [1.6, 1]
마지막 요소를 삭제하는 벡터는 다음과 같습니다. [1.6]
0 번째 위치에 요소 1.8888을 추가하십시오 : [1.8888, 1.6]
0 번째 위치의 요소를 A로 변경하십시오 : [A, 1.6]
======== 벡터 데이터 구조의 테스트 끝 ======
2. Arraylist
public static void arraylisttest () {arraylist <double> arraylist = new arraylist <double> (); ArrayList.add (1.0); ArrayList.add (4.0); ArrayList.add (5.0); ArrayList.add (2.3); System.out.println ( "간단한 추가는 끝에서 요소를 추가하는 수단 :" + arraylist); System.out.println ( "size ()가 포함 된 요소 수를 찾을 수 있습니다." + arraylist.size ()); Arraylist.remove (1); System.out.println ( "제거 (1)는 첫 번째 요소를 삭제하는 것을 의미합니다. 카운트가 0에서 시작되므로 요소 4 :" + arraylist); ArrayList.remove (ArrayList.Size () -1); System.out.println ( "마지막 요소를 삭제하기위한 배열 목록은 :" + arraylist); ArrayList.add (0, 1.8888); System.out.println ( "0 번째 위치에 1.8888 요소 추가 :" + arraylist); ArrayList.Set (0, 9.0); System.out.println ( "0 번째 위치에서 요소를 A로 변경합니다." + ArrayList); collections.sort (arraylist); System.out.println ( "정렬은 ArrayList가 추상 유형이 아닌 경우 지원됩니다" + ArrayList); } 여기서 Arraylist가 마지막 요소를 삭제하는 방식이 벡터와 다르다는 것을 알 수 있습니다. 주된 이유는 ArrayList에 마지막 요소를 제거 할 LastElement () 메소드가 없기 때문입니다. 제거 ()는 마지막 요소의 위치를 결정하는 데만 사용할 수 있습니다. 이 메소드가 다음과 같은 주요 기능에서 호출되는 경우 :
System.out.println ( "========== Arraylist 데이터 구조의 시작 테스트 ========"); ArrayListTest (); System.out.println ( "========= Arraylist 데이터 구조 테스트 ===================);
그런 다음 다음 실행 결과가 얻어집니다.
======= ArrayList 데이터 구조의 시작 테스트 ======
간단한 추가는 끝에서 요소를 추가하는 것을 의미합니다. [1.0, 4.0, 5.0, 2.3]
크기 ()가 포함 된 요소 수를 찾을 수 있습니다
제거 (1)는 첫 번째 요소를 삭제하는 것을 의미합니다. 카운트는 0에서 시작하기 때문에 요소 4 : [1.0, 5.0, 2.3]
마지막 요소를 삭제하기위한 배열 목록은 다음과 같습니다. [1.0, 5.0]
0 번째 위치에 요소 1.8888을 추가하십시오 : [1.8888, 1.0, 5.0]
0 번째 위치의 요소를 A로 변경하십시오. [9.0, 1.0, 5.0]
ArrayList가 추상 유형이 아닌 경우 정렬이 지원됩니다 [1.0, 5.0, 9.0]
======== ArrayList 데이터 구조의 테스트 종료 ======
위의 두 가지 예에서 벡터와 배열 목록은 일반적인 배열, 즉 교과서 int array에서 가르치는 1 차원 배열이라는 것을 알 수 있습니다 [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; 훨씬 더 강력합니다. 모든 위치에 요소를 삽입하거나 배열을 가로지 않고 지정된 위치에서 요소를 삭제할 수 있습니다. 물론, 당신은 여전히이 배열이 당신을 위해 어떻게 통과되는지 알아야합니다. 실제로, ArrayList 및 일반 1 차원 배열을 완전히 변환 할 수 있으며 ArrayList를 사용하여 배열에 버블 정렬을 쓰지 않고 배열을 직접 정렬 할 수도 있습니다. 배열을 collections.sort ()로 직접 정렬 할 수 있습니다. 그리고 collections.reverse ()를 사용하십시오. 역 분류를 달성합니다. 물론, 그것은 여전히 같은 문장입니다. 당신을 위해, 당신은 여전히이 배열이 어떻게 정렬되는지 알아야합니다.
예를 들어, 다음 방법은 1 차원 배열 int 배열의 정렬 및 역 분류를 구현합니다 [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; 먼저 배열을 ArrayList로 변환 한 다음 collections.sort ()로 정렬하십시오. 그리고 collections.reverse (); 그리고 마지막으로 배열리스트 컨텐츠를 1 차원 배열로 다시 변환합니다.
public static void arraylistort () {int array [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; ArrayList <integer> arraylist = new ArrayList <integer> (); for (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); for (int i = 0; i <array.length; i ++) arraylist.add (array [i]); collections.sort (arraylist); for (int i = 0; i <array.length; i ++) arraylist.add (array [i]); collections.sort (arraylist); for (int i = 0; i <array.length; i <array.length; i ++) arraylist.add (array [i]); collections.sort (arraylist); for (int i = 0; i <array.length; i <array.length; i ++) arraylist.add (array [i]); collections.sort (arraylist); for (int i = 0; i <array.length; i ++) 배열 [i] = arraylist.get (i); System.out.print ( "정렬 된 배열 :"); for (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); collections.reverse (arraylist); for (int i = 0; i <array.length; i ++) 배열 [i] = arraylist.get (i); System.out.print ( "반대로 정렬 된 배열 :"); for (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); // 정렬 후 ArrayList를 파괴합니다. ArrayList = NULL; //이 문장은 Java가 즉시 쓰레기를 재활용한다고 제안합니다. 물론,이 문장이 괜찮은지 여부에 관계없이 Java는 런 프로세스 중에 자동으로 쓰레기를 제거합니다. } 주요 함수 에서이 방법은 다음과 같이 호출됩니다.
System.out.println ( "=========== Java 배열 정렬 시작 ========="); ArrayListsort (); System.out.println ( "=============== Java Array Sort Ends ==========);
다음과 같은 실행 결과를 얻을 수 있습니다.
======== Java 배열 정렬 시작 ======
8,7,100,88,6,4,5,33,7, 분류 배열 : 4,5,6,7,7,8,33,88,100, 반비례 배열 : 100,88,33,8,7,6,5,4,
========== Java 어레이 정렬 종료 ======
또한 이전 "Java에서 목록 사용에 대한 간단한 소개"에 대해서도 마찬가지입니다 (링크를 열려면 클릭하십시오).
2. 수집 해시 세트
또한 수학 수집 컬렉션 개념과 정확히 동일한 컬렉션 해시 세트가 있습니다. 하나 이상의 요소로 구성된 세트를 세트라고합니다. 해시셋은 다음과 같습니다.
1. 결정론 . 세트의 요소는 결정적이어야합니다. 이것은 말도 안됩니다. 결정 론적이어야합니다. 여전히 불확실한 것을 넣을 수 있습니까?
2. 상호 반대 성별 , 세트의 요소는 다릅니다. 예를 들면 : A = {1, a}를 설정하면 A는 1과 같을 수 없습니다. 즉, 2 개의 1을 해시 세트에 넣으면 자동으로 1이됩니다.
3. 장애 , 세트에는 요소의 순서가 없습니다. 따라서 해시셋은 정렬 작업을 수행해서는 안됩니다 (예 : 다음 방법).
public static void HashsetTest () {Hashset <botort> Hashset = new Hashset <botort> (); Hashset.add (1); Hashset.add (1); Hashset.add (5); Hashset.add (2.3); System.out.println ( "간단한 추가는 끝에서 요소를 추가하는 수단 :" + Hashset); System.out.println ( "size ()가 포함 된 요소의 수를 찾을 수 있습니다." + hashset.size ()); 해시 셋 .remove (1); System.out.println ( "제거 (1)는 요소 '1':" + Hashset)을 삭제하는 것을 의미합니다. Hashset.remove ( "ASD"); System.out.println ( " 'ASD'요소가 없으면 제거하지 않습니다 :" + HASHSET); hashset.add (1.8888); System.out.println ( "1.8888 추가 요소 :" + Hashset); }주요 함수 에서이 방법을 호출하십시오.
System.out.println ( "========== 해시 세트 데이터 구조의 시작 ========="); HashsetTest (); system.out.println ( "========== 해시 세트 데이터 구조의 테스트 종료 ===================);
결과는 다음과 같습니다.
======= 테스트는 해시 세트 데이터 구조 ======로 시작합니다
간단한 추가는 끝에서 요소를 추가하는 것을 의미합니다. [1, 5, 2.3]
크기 ()가 포함 된 요소 수를 찾을 수 있습니다. 3
제거 (1) rement '1'을 삭제하는 수단 '1': [5, 2.3]
'ASD'요소가 없으면 제거는 아무것도하지 않습니다. [5, 2.3]
요소 1.8888을 추가하십시오 : [5, 1.8888, 2.3]
======== 해시 세트 데이터 구조의 테스트 종료 ======
Hashset에는 add () 메소드와 remove () 메소드가 있습니다. add ()에 추가 된 요소는 순서대로 진행됩니다. System.out.println ()로 인쇄 된 결과는 다른 순서로있을 수 있습니다. 위의 벡터 및 배열 목록과 동일 할 수는 없습니다. 저장된 요소가 객체가 아닌 한 collections.sort (arraylist); 그것들을 분류하는 데 사용될 수 있습니다.
3. 듀얼 해시 맵
여기서 사용법은 기본적으로 위의 데이터와 동일하며 매우 간단합니다. 객체를지도에 넣고 맵의 객체를 제거 할 수 있지만 바이너리 해시 맵을 트리플으로 사용하는 것은 잘못입니다. 객체에 너무 많은 요소가 포함 된 경우 클래스 사용을 고려해야합니다. 일반 변수와 클래스 클래스를 방해하는 Java의 컬렉션 수업에 집착하는 대신.
예를 들어, 다음 방법은 해시 맵을 트리플로 변경하려는 오류 작업을 보여줍니다.
public static void maptest () {system.out.println ( "============== 맵 사용 시작 ==============); HashMap <String, String> map = new Hashmap <string, String, String> (); Hashmap <String, Hashmap <string >> bigmap = new hashmap <string <, hashmap 문자열 (); "key1", "key2", "test1"; System.out.println ( "test1"). get ( "key1"); system.out.println (bigmap.get ( "test2"). get ( "key2"); 부정확하게 =========================================================================================================================================================== =================================================================== ====================================================================== =================================================================== ====================================================================== ====================================================================== ====================================================================== 기본 기능 에서이 코드를 호출하면 다음과 같은 결과가 발생합니다.
======== 테스트는 맵 데이터 구조 ======로 시작합니다
======== 맵 사용 시작 오류 ======
{test1 = {key2 = 4, key1 = 3}, test2 = {key2 = 4, key1 = 3}}
3
4
3
4
======= 맵 사용 종료 오류 ======
========= MAP의 올바른 사용 시작 ======
{key3 = 3, key2 = 2, key1 = 1}
======== 맵의 올바른 사용 종료 ======
======== 맵 데이터 구조 테스트 ======
이 프로그램은 원래 {test1, key1,1}, {test1, key2,2}, {test2, key3,3}, {test2, key4,4}를 구성하려고 노력했습니다.
그러나 모든 BigMap에는 여전히 그지도가 있습니다. 맵을 지우면 test1의 맵도 지워집니다. 누군가가 여러 MAP1, MAP2를 만들려고 노력했습니다. 그러면 간단한 클래스를 사용하여 더 명확하게 보일 수 있으며 앞으로 수업에서 방법을 작성하고 상속받을 수 있습니다.
4. 노트
새 벡터, Arraylist, Hashset 또는 Hashmap을 만들 때 다음과 같이 쓸 수 있습니다.
Collection <String> A = New ArrayList <string> ();
List <string> a = new Vector <string> ();
컬렉션 인터페이스에서 상속되는 ArrayList, 벡터, 링크드리스트, 해시 세트 및 트리 셋이 있기 때문에 맵 인터페이스에서 상속되는 해시 맵 및 해시 가능이기 때문에 상속, 다형성, 캡슐화 및 JAVA의 기타 클래스의 문제입니다. 물론, 동료들이 더 명확하게보기 위해서는 여기에서 멋진 이름 지정을 연주하지 말고, 명확한 ArrayList <integer> arraylist = new ArrayList <integer> ()를 작성하십시오. 자바에서 수업을 이해하지 못한다고 말하는 사람은 아무도 없습니다.
위는이 기사의 모든 내용입니다. 모든 사람의 학습에 도움이되기를 바랍니다. 모든 사람이 wulin.com을 더 지원하기를 바랍니다.