기술나눔

[Java 데이터 구조] 최초의 선형 테이블 중 하나: 순차 테이블

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Java를 사용한 시퀀스 테이블의 간단한 구현

시퀀스 테이블은 연속된 물리적 주소를 갖는 저장 단위를 사용하여 데이터 요소를 순차적으로 저장하는 선형 구조입니다. 일반적으로 배열 저장 장치가 사용됩니다. 어레이의 데이터 추가, 삭제, 확인 및 수정을 완료합니다.

선형 테이블에는 일반적으로 다음 방법이 포함됩니다.

공개 클래스 MyArrayList {
개인 int[] 배열;
개인 int 크기;
   //기본 생성 방법은 기본적으로 공간을 할당합니다.
SeqList(){ }
    // 시퀀스 테이블의 기본 용량을 지정된 용량으로 설정합니다.
SeqList(int initcapacity){ }

   // 새 요소를 추가합니다. 기본적으로 배열 끝에 추가됩니다.
public void add(int 데이터) { }
    //pos 위치에 요소 추가
public void add(int pos, int data) { }
   // 요소가 포함되어 있는지 확인
public boolean contains(int toFind) { return true; }
    // 요소에 해당하는 위치를 찾습니다.
public int indexOf(int toFind) { return -1; }
    // pos 위치의 요소를 가져옵니다.
공개 int get(int pos) { return -1; }
   // pos 위치의 요소를 값으로 설정합니다.
public void set(int pos, int value) { }
    //키워드 key의 첫 번째 발생을 삭제합니다.
public void remove(int toRemove) { }
   // 시퀀스 테이블의 길이를 가져옵니다.
공개 int 크기() { return 0; }
    //시퀀스 테이블 지우기
공개 무효 clear() { }
   
   //시퀀스 테이블 인쇄
공개 무효 디스플레이() { }
}

다음으로, 위의 방법에 따라 int 유형의 시퀀스 테이블을 구현합니다.

  1. import java.util.Arrays;
  2. public class MyArrayList {
  3.     private int[] elem;
  4.     private int usedSize;
  5.     private static final int DEFAULT_SIZE = 10;
  6.     public MyArrayList(){
  7.         elem = new int[DEFAULT_SIZE];
  8.     }
  9.     public MyArrayList(int initCapacity){
  10.         elem = new int[initCapacity];
  11.     }
  12.  
  13.     private boolean checkCapacity(){
  14.         if(this.usedSize == elem.length){
  15.             return true;
  16.         }
  17.         return false;
  18.     }
  19.  
  20.     public void display(){
  21.         for (int i = 0; i < this.usedSize; i++) {
  22.             System.out.print(this.elem[i] + " ");
  23.         }
  24.     }
  25.     public void add(int data){
  26.         if(checkCapacity()){
  27.             this.elem = Arrays.copyOf(this.elem,2*elem.length);
  28.         }
  29.         this.elem[this.usedSize] = data;
  30.         this.usedSize++;
  31.         return;
  32.     }
  33.     public void add(int pos,int data){
  34.         if(pos > this.usedSize || pos < 0){
  35.             throw new PosOutOfBoundsException("插入位置错误！");
  36.         }
  37.         if(checkCapacity()){
  38.             this.elem = Arrays.copyOf(this.elem,2*elem.length);
  39.         }
  40.         for (int i = this.usedSize - 1; i >=pos ; i--) {
  41.             elem[i+1] = elem[i];
  42.         }
  43.         this.elem[pos] = data;
  44.         this.usedSize++;
  45.         return;
  46.     }
  47.  
  48.     public boolean contains(int data){
  49.         for (int i = 0; i < this.usedSize; i++) {
  50.             if(this.elem[i] == data){
  51.                 return true;
  52.             }
  53.         }
  54.         return false;
  55.     }
  56.  
  57.     public int indexof(int data){
  58.         for (int i = 0; i < this.usedSize; i++) {
  59.             if(this.elem[i] == data){
  60.                 return i;
  61.             }
  62.         }
  63.         return -1;
  64.     }
  65.     public int get(int pos){
  66.         if(pos >= this.usedSize || pos < 0){
  67.             throw new PosOutOfBoundsException("输入的位置错误！");
  68.         }
  69.         return this.elem[pos];
  70.     }
  71.     public void set(int pos,int data){
  72.         if(pos >= this.usedSize || pos < 0){
  73.             throw new PosOutOfBoundsException("输入的位置错误！");
  74.         }
  75.         this.elem[pos] = data;
  76.     }
  77.     public int size(){
  78.         return this.usedSize;
  79.     }
  80.     public void remove(int data){
  81.         if(this.contains(data)){
  82.             int pos = this.indexof(data);
  83.             for (int i = pos; i < this.usedSize - 1; i++) {
  84.                 this.elem[pos] = this.elem[pos+1];
  85.             }
  86.             this.usedSize--;
  87.         }else{
  88.             throw new PosOutOfBoundsException("没有该元素");
  89.         }
  90.     }
  91.     public void clear(){
  92.         this.usedSize = 0;
  93.         return;
  94.     }
  95. }

ArrayList 소개

컬렉션 프레임워크에서 ArrayList는 List 인터페이스를 구현하는 일반 클래스입니다. 구체적인 프레임워크 다이어그램은 다음과 같습니다.

  • ArrayList는 일반적인 방식으로 구현되며 사용하기 전에 인스턴스화해야 합니다.
  • ArrayList는 ArrayList가 무작위 액세스를 지원함을 나타내는 RandomAccess 인터페이스를 구현합니다.
  • ArrayList는 ArrayList가 복제될 수 있음을 나타내는 Cloneable 인터페이스를 구현합니다.
  • ArrayList는 ArrayList가 직렬화를 지원함을 나타내는 직렬화 가능 인터페이스를 구현합니다.
  • Vector와 달리 ArrayList는 스레드로부터 안전하지 않으며 단일 스레드에서 사용할 수 있습니다. 다중 스레드에서는 Vector 또는
  • 복사온라이트배열목록
  • ArrayList의 맨 아래 레이어는 연속적인 공간이며 동적으로 확장될 수 있는 동적 유형의 시퀀스 목록입니다.

ArrayList를 사용하는 방법

ArrayList 생성자

ArrayList의 생성자 메서드:

ArrayList(); //매개변수 구성 없음

ArrayList(컬렉션<? extends E> c); //다른 컬렉션을 사용하여 ArrayList를 구축합니다.

ArrayList(intinitialCapacity); //시퀀스 테이블의 초기 용량을 지정합니다.

코드 예:

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list1 = new ArrayList<>();//无参构造
  4.         List<Integer> list2 = new ArrayList<>(10);//指定容量
  5.         list2.add(1);
  6.         list2.add(2);
  7.         list2.add(3);
  8.         List<Integer> list3 = new ArrayList<>(list2);//利用其他 Collection 构建 ArrayList
  9.     }
  10. }

ArrayList의 일반적인 작업

테일 플러그

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();//无参构造
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         System.out.println(list);
  8.     }
  9. }

지정된 위치에 요소 삽입

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.add(1,4);
  8.         System.out.println(list);
  9.     }
  10. }

다른 시퀀스 목록의 삽입 요소 종료

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer>  list1 = new ArrayList<>();
  4.         list1.add(4);
  5.         list1.add(5);
  6.         list1.add(6);
  7.         List<Integer> list = new ArrayList<>();
  8.         list.add(1);
  9.         list.add(2);
  10.         list.add(3);
  11.         list.addAll(list1);
  12.         System.out.println(list);
  13.     }
  14. }

지정된 위치의 요소를 삭제합니다.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.remove(1);
  8.         System.out.println(list);
  9.     }
  10. }

지정된 데이터 삭제

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.remove(new Integer(2));
  8.         System.out.println(list);
  9.     }
  10. }

지정된 위치의 요소를 가져옵니다

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         System.out.println(list.get(1));
  8.     }
  9. }

지정된 위치의 요소를 새로운 데이터로 설정합니다.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.set(1,4);
  8.         System.out.println(list);
  9.     }
  10. }

시퀀스 목록 지우기

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.clear();
  8.         System.out.println(list);
  9.     }
  10. }

요소가 시퀀스 목록에 있는지 확인

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         System.out.println(list.contains(2));
  8.         System.out.println(list.contains(4));
  9.     }
  10. }

지정된 첫 번째 요소의 인덱스를 반환합니다.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.add(1);
  8.         System.out.println(list.indexOf(1));
  9.     }
  10. }

마지막으로 지정된 요소의 인덱스를 반환합니다.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.add(1);
  8.         System.out.println(list.lastIndexOf(1));
  9.     }
  10. }

목록의 일부를 가로채기

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         System.out.println(list.subList(0,2));
  8.     }
  9. }

ArrayList를 순회하는 세 가지 방법

ArrayList는 for 루프 + 아래 첨자, foreach 강화 루프 및 반복기 사용의 세 가지 방법으로 탐색할 수 있습니다.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         //使用fori遍历
  8.         for (int i = 0; i < list.size(); i++) {
  9.             System.out.print(list.get(i));
  10.         }
  11.         System.out.println();
  12.         //使用foreach遍历
  13.         for(Integer integer:list){
  14.             System.out.print(integer);
  15.         }
  16.         System.out.println();
  17.         //使用迭代器遍历
  18.         Iterator<Integer> it = list.listIterator();
  19.         while(it.hasNext()){
  20.             System.out.print(it.next());
  21.         }
  22.     }
  23. }

작업 결과:

ArrayList의 시나리오 사용법

셔플링 알고리즘

카드 한 벌을 무작위로 섞어 세 사람에게 각각 5장의 카드를 나누어 줍니다.

알고리즘의 원본 코드 위치:

shufflecards · Always Freshwater Fish/Java Classic 예제 - 코드 클라우드 - 오픈 소스 중국(gitee.com)

양희삼각형

주제 설명:

암호:

  1. public class Test {
  2.     public static List<List<Integer>> generate(int numRows) {
  3.         List<List<Integer>> list = new LinkedList<>();
  4.         for (int i = 0; i < numRows; i++) {
  5.             List<Integer> row = new LinkedList<>();
  6.             for (int j = 0; j < i + 1; j++) {
  7.                 if (j == 0 || i == j) {
  8.                     row.add(1);
  9.                 } else {
  10.                     row.add(list.get(i - 1).get(j - 1) + list.get(i - 1).get(j));
  11.                 }
  12.             }
  13.             list.add(row);
  14.         }
  15.         return list;
  16.     }
  17.  
  18.     public static void main(String[] args) {
  19.         Scanner scanner = new Scanner(System.in);
  20.         int numRows = scanner.nextInt();
  21.         List<List<Integer>> list = generate(numRows);
  22.         for (int i = 0; i < numRows; i++) {
  23.             for (int j = 0; j < i + 1; j++) {
  24.                 System.out.print(list.get(i).get(j) + " ");
  25.             }
  26.             System.out.println();
  27.         }
  28.     }
  29. }

실행 결과 그래프:

개인 프로필

그는 30년 이상 기술 연구에 전념해 왔으며, java, linux, javascript, php, css 등 다양한 언어에 능숙하며, 오픈 소스 분야에 많은 공헌을 했습니다. 나중에 참조할 수 있도록 기술 개발의 일부 문제를 공유하는 개발자 문서 스테이션입니다.

내 연락처 정보

우편