Java LinkedList (링크드 리스트)

이 튜토리얼에서는 LinkedList 클래스에 대해 많은 예제를 통해 자세히 이해할 수 있습니다.

Java 컬렉션 프레임워크의 LinkedList 클래스는 링크드 리스트 데이터 구조의 기능을 제공합니다.

LinkedList에서 구현된 인터페이스

• Java List 인터페이스

• Java Queue 인터페이스

• Java Deque 인터페이스

Java의 LinkedList 구현

Java LinkedList 클래스는 양방향 링크드 리스트 구현을 제공합니다.

링크드 리스트의 각 요소는노드그것은3필드가 있습니다:

• Prev - 이전 요소의 주소를 저장하는 목록에 저장됩니다. 첫 번째 요소는 null입니다.

• Next - 다음 요소의 주소를 저장하는 목록에 저장됩니다. 마지막 요소는 null입니다.

• Data - 실제 데이터를 저장합니다.

링크드 리스트의 요소는 순서대로 저장되지 않습니다. 대신, 그들은 분산되어 있으며 링크(Prev와 Next)를 통해 연결됩니다.

여기서 링크드 리스트에 포함된3요소.

• Dog - 첫 번째 요소는 null을 이전 주소로, Cat의 주소를 다음 주소로 설정합니다

• Cat - 두 번째 요소는 Dog의 주소를 이전 주소로, Cow의 주소를 다음 주소로 설정합니다

• Cow - 마지막 요소는 Cat의 주소를 이전 주소로, null을 다음 요소로 설정합니다

LinkedList 생성

이렇게 Java에서 링크드 리스트를 생성하는 방법입니다:

LinkedList<Type> linkedList = new LinkedList<>();

여기서 Type은 링크드 리스트의 타입을 의미합니다. 예를 들어,

//정수형 링크드 리스트 생성
LinkedList<Integer> linkedList = new LinkedList<>();
//문자형 링크드 리스트 생성
LinkedList<String> linkedList = new LinkedList<>();

인터페이스를 사용하여 LinkedList 생성

예시를 들어보겠습니다.

List<String> animals1　= new LinkedList<>();

여기서, List 인터페이스를 사용하여 animals라는 링크드 리스트를 선언했습니다1만큼 링크드 리스트는 List 인터페이스의 메서드에 액세스할 수 있습니다.

다른 예시를 들어보겠습니다.

Queue<String> animals2　= new LinkedList<>();
Deque<String> animals3　= new LinkedList<>();

여기서, animal2Queue 인터페이스의 메서드에 액세스할 수 있습니다.

하지만, animal3Deque와 Queue 인터페이스의 메서드에 액세스할 수 있습니다. 이는 Deque가 Queue의 서브 인터페이스인 이유입니다.

LinkedList의 메서드

LinkedList는 다양한 메서드를 제공하여 링크드 리스트에서 다양한 작업을 수행할 수 있게 합니다.

요소를 LinkedList에 추가

1. 요소 추가:}}add() 메서드 사용

요소(노드)를 링크드리스트의 마지막에 추가하려면 add() 메서드를 사용합니다. 예를 들어,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//요소를 LinkedList에 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Cat, Horse]

2. 요소 추가: 인덱스 사용

또한 인덱스를 사용하여 요소를 링크드리스트에 추가할 수 있습니다. 예를 들어,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//인덱스 사용 요소 추가
　　　　　　　　animals.add(0,"Dog");
　　　　　　　　animals.add(1,"Cat");
　　　　　　　　animals.add(2,"Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Cat, Horse]

3. 요소 추가: 링크드리스트 추가

링크드리스트의 모든 요소를 다른 링크드리스트에 추가하려면 addAll() 메서드를 사용합니다. 예를 들어,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> mammals = new LinkedList<>();
　　　　　　　　mammals.add("Dog");
　　　　　　　　mammals.add("Cat");
　　　　　　　　mammals.add("Horse");
　　　　　　　　System.out.println("Mammals: ")　+　mammals);
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Crocodile");
　　　　　　　　//mammals의 모든 요소를 animals에 추가합니다
　　　　　　　　animals.addAll(mammals);
　　　　　　　　System.out.println("Animals: ")　+　animals);
　　　　}
}

출력 결과

Mammals: [Dog, Cat, Horse]
Animals: [Crocodile, Dog, Cat, Horse]

4. 요소 추가: listIterator() 메서드 사용

또한 elements 추가할 수 있는 listsIterator() 메서드를 사용할 수 있습니다. 이를 사용하려면 java.util.ListIterator 패키지를 가져오아야 합니다. 예를 들어,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//ListIterator 객체를 생성합니다.
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.add("Dog");
　　　　　　　　listIterate.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Cat]

LinkedList 요소 접근

1. 요소 접근: get() 메서드 사용

. 요소 접근: get() 메서드 사용

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//링크드리스트에서 요소를 가져오려면 get() 메서드를 사용할 수 있습니다. 예를 들어,
　　　　　　　　String str = animals.get(1);
　　　　　　　　System.out.print("인덱스1위의 요소: "　+　str);
　　　　}
}

출력 결과

LinkedList: [Dog, Horse, Cat]
인덱스1위의 요소: Horse

2. 요소 접근: iterator() 메서드 사용

링크드리스트의 요소를 순회하려면 iterator() 메서드를 사용할 수 있습니다. 이 메서드를 사용하려면 java.util.Iterator 패키지를 가져오아야 합니다. 예를 들어,

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Iterator 객체를 생성합니다
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

출력 결과

LinkedList: Dog, Cat, Horse,

이곳에서는,

• hasNext() - 다음 요소가 존재하면 true를 반환합니다

• next() - 다음 요소를 반환합니다

3.요소 접근: listIterator() 메서드를 사용합니다

링크드리스트의 요소를 순회하려면 listIterator() 메서드를 사용할 수 있습니다. 이 메서드를 사용하려면 java.util.ListIterator 패키지를 임포트해야 합니다.

listsIterator() 메서드는 링크드리스트에 더 적합합니다. 이는 listIterator() 객체가 뒤로도 순회할 수 있기 때문입니다. 예를 들어,

import java.util.LinkedList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//ListIterator 객체를 생성합니다.
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(listIterate.hasNext()) {
　　　　　　　　　　　　System.out.print(listIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//　뒤로 이동하여 순회합니다
　　　　　　　　System.out.print("\n반대로 LinkedList: ");
　　　　　　　　while(listIterate.hasPrevious()) {
　　　　　　　　　　　　System.out.print(listIterate.previous());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

출력 결과

Dog, Horse, Cat, 순서로 LinkedList:
Cat, Horse, Dog, 순서로 반대로 LinkedList:

이곳에서는,

• hasNext() - 다음 요소가 존재하면 true를 반환합니다

• next() - 다음 요소를 반환합니다

• hasPrevious() - 이전 요소가 존재하면 true를 반환합니다

• previous() - 이전 요소를 반환합니다

LinkedList 요소를 검색합니다

1.요소 검색: contains() 메서드를 사용합니다

특정 요소가 링크드리스트에 포함되어 있는지 확인하려면 contains() 메서드를 사용합니다. 예를 들어,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Dog이 링크드리스트에 있는지 확인합니다
　　　　　　　　if(animals.contains("Dog")) {
　　　　　　　　　　　　System.out.println("Dog이 LinkedList에 있습니다.")
　　　　　　　　}
　　　　}
}

출력 결과

LinkedList: [Dog, Horse, Cat]
Dog이 LinkedList에 있습니다

2.indexOf() 메서드를 사용하여 요소를 검색합니다

• indexOf() - 요소가 첫 번째로 나타난 인덱스 값을 반환합니다

• lastIndexOf() - 요소가 마지막으로 나타난 인덱스 값을 반환합니다

예를 들어,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//　링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Dog이 첫 번째로 나타났습니다
　　　　　　　　int index1　= animals.indexOf("Dog");
　　　　　　　　System.out.println("Dog이 첫 번째로 나타난 인덱스 값: ")　+　인덱스1);
　　　　　　　　//Dog이 마지막으로 나타났습니다
　　　　　　　　int index2　= animals.lastIndexOf("Dog");
　　　　　　　　System.out.println("Dog의 마지막 등장 인덱스 값: ",　+　인덱스2);
　　　　}
}

출력 결과

LinkedList: [Dog, Horse, Cat, Dog]
Dog의 첫 번째 등장 인덱스 값: 0
Dog의 마지막 등장 인덱스 값:　3

주의:지정된 요소를 찾지 못하면 indexOf()와 lastIndexOf() 모두-1.

LinkedList 요소 변경

1

링크 목록의 요소를 변경하려면 set() 메서드를 사용할 수 있습니다. 예를 들어,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//변경 인덱스 값:3요소
　　　　　　　　animals.set(3, "Zebra");
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Horse, Cat, Dog]
새 LinkedList: [Dog, Horse, Cat, Zebra]

2

또한 listIterator() 메서드를 사용하여 링크 목록의 요소를 변경할 수 있습니다. 예를 들어,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//　링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//ListIterator 객체를 생성합니다.
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//next() 메서드로 반환된 요소를 변경합니다.
　　　　　　　　listIterate.set("Cow");
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Cat, Horse]
새 LinkedList: [Cow, Cat, Horse]

LinkedList 요소 제거

1

링크 목록에서 요소를 제거하려면 remove() 메서드를 사용할 수 있습니다. 예를 들어,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Zebra");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//제거 인덱스 값:1요소
　　　　　　　　String str = animals.remove(1);
　　　　　　　　System.out.println("요소 제거: ",　+　str);
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Horse, Cat, Zebra]
요소 제거: Horse
새 LinkedList: [Dog, Cat, Zebra]

2

또한 listsIterator() 메서드를 사용하여 링크 목록에서 요소를 제거할 수 있습니다. 예를 들어,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//ListIterator 객체를 생성합니다.
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//next()가 반환한 요소를 제거합니다
　　　　　　　　listIterate.remove();
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Cat, Horse]
새로운 LinkedList: [Cat, Horse]

3. 요소 제거: clear() 메서드 사용

모든 요소를 링크드 리스트에서 제거하려면 clear() 메서드를 사용합니다. 예를 들어:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//모든 요소 제거
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Cat, Horse]
새로운 LinkedList: []

주의:모든 요소를 제거할 수 있는 removeAll() 메서드도 사용할 수 있습니다. 그러나 clear() 메서드는 removeAll() 메서드보다 효율적입니다.

4. 요소 제거: removeIf() 메서드 사용

요소가 특정 조건을 만족하면, 그들을 링크드 리스트에서 제거할 수도 있습니다. 이를 위해 removeIf() 메서드를 사용합니다. 예를 들어:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<Integer> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add(2);
　　　　　　　　animals.add(3);
　　　　　　　　animals.add(4);
　　　　　　　　animals.add(5);
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//　모든4요소
　　　　　　　　animals.removeIf((Integer i)->i <　4);
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　　　　/**　여기서 lambda 표현식을 사용했습니다
　　　　　　　*　　지금 기억하세요
　　　　　　　*　　removeIf()의 매개변수는 조건입니다
　　　　　　　*/
　　　　}
}

출력 결과

LinkedList: [2,　3,　4,　5]
새로운 LinkedList: [4,　5]

주의: (Integer i)->i<4 이는 lambda 표현식입니다. lambda 표현식에 대해 알고 싶다면, 다음을 방문하세요Java Lambda 표현식

LinkedList as Deque and Queue

LinkedList 클래스는 Queue와 Deque 인터페이스도 구현하므로 이 인터페이스의 메서드를 구현할 수 있습니다. 다음은 일부 일반적인 메서드입니다:

addFirst()과 addLast() 메서드

• addFirst() - 지정된 요소를 링크드 리스트의 시작에 추가합니다

• addLast() - 지정된 요소를 링크드 리스트의 마지막에 추가합니다

예를 들어,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//요소를 LinkedList의 시작 부분에 추가합니다
　　　　　　　　animals.addFirst("Cow");
　　　　　　　　animals.addFirst("Dog");
　　　　　　　　animals.addFirst("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//LinkedList의 마지막에 요소 추가
　　　　　　　　animals.addLast("Zebra");
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Cat, Dog, Cow]
새 LinkedList: [Cat, Dog, Cow, Zebra]

getFirst()와 getLast() 메서드

• getFirst() - 첫 번째 요소를 반환합니다

• getLast() - 마지막 요소를 반환합니다

예를 들어,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//링크에서 첫 번째 요소를 가져옵니다
　　　　　　　　String str1　= animals.getFirst();
　　　　　　　　System.out.println("첫 번째 요소: ");　+　str1);
　　　　　　　　//링크에서 마지막 요소를 가져옵니다
　　　　　　　　String str2　= animals.getLast();
　　　　　　　　System.out.println("마지막 요소: ");　+　str2);
　　　　}
}

출력 결과

LinkedList: [Dog, Horse, Cat]
첫 번째 요소: Dog
마지막 요소: Cat

removeFirst()와 removeLast() 메서드

• removeFirst() - 첫 번째 요소를 제거합니다

• removeLast() - 마지막 요소를 제거합니다

예를 들어,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//LinkedList에서 첫 번째 요소를 제거합니다
　　　　　　　　String str1　= animals.removeFirst();
　　　　　　　　System.out.println("삭제된 요소: ");　+　str1);
　　　　　　　　//LinkedList에서 마지막 요소를 제거합니다
　　　　　　　　String str2　= animals.removeLast();
　　　　　　　　System.out.println("삭제된 요소: ");　+　str2);
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Horse, Cat]
삭제된 요소: Dog
삭제된 요소: Cat
새 LinkedList: [Horse]

peek() 메서드

peek() 메서드는 링크의 첫 번째 요소(헤드)를 반환합니다. 예를 들어,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//LinkedList의 첫 번째 요소를 접근합니다
　　　　　　　　String str = animals.peek();
　　　　　　　　System.out.println("요소 접근: ");　+　str);
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Horse, Cat]
요소 접근: Dog
새로운 LinkedList: [Dog, Horse, Cat]

poll() 메서드

poll() 메서드는 첫 번째 요소를 반환하고 목록에서 삭제합니다. 예를 들어,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//최초의 요소를 반환하고 삭제합니다
　　　　　　　　String str = animals.poll();
　　　　　　　　System.out.println("삭제된 요소: ");　+　str);
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Horse, Cat]
삭제된 요소: Dog
새 LinkedList: [Horse, Cat]

offer() 메서드

이 offer() 메서드는 지정된 요소를 링크 목록의 마지막에 추가합니다. 예를 들어,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//링크드리스트에 요소 추가
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//LinkedList의 마지막에 요소 추가
　　　　　　　　animals.offer("Cat");
　　　　　　　　System.out.println("새로운 LinkedList: ");　+　animals);
　　　　}
}

출력 결과

LinkedList: [Dog, Horse]
새로운 LinkedList: [Dog, Horse, Cat]

LinkedList 이터레이터 순회

1.forEach 루프로 순회

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//리스트 생성
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//forEach 루프 사용
　　　　　　　　System.out.println("링크드리스트 요소 접근:");
　　　　　　　　for(String animal: animals) {
　　　　　　　　　　　　System.out.print(animal);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

출력 결과

LinkedList: [Cow, Cat, Dog]
링크드리스트 요소 접근:
Cow, Cat, Dog,

2.for문 사용

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//리스트 생성
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//for문 사용
　　　　　　　　System.out.println("링크드리스트 요소 접근:");
　　　　　　　　for(int i=0; i < animals.size(); i++) {
　　　　　　　　　　　　System.out.print(animals.get(i));
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

출력 결과

LinkedList: [Cow, Cat, Dog]
링크드리스트 요소 접근:
Cow, Cat, Dog,

두 예제에서 모두 루프를 사용하여 링크드리스트의 각 요소를 순회합니다.

3.iterator() 메서드 사용

iterator() 메서드를 사용하여 링크드리스트의 요소에 접근할 수 있습니다. 이 메서드를 사용하려면 java.util.Iterator 패키지를 가져오아야 합니다.

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//리스트 생성
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//iterator() 메서드 사용
　　　　　　　　System.out.println("LinkedList 사용 iterator() 메서드:");
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

출력 결과

LinkedList: [Cow, Cat, Dog]
LinkedList는 iterator() 메서드를 사용합니다:
Cow, Cat, Dog,

LinkedList와 ArrayList

LinkedList와 ArrayList은 Collections 프레임워크의 List 인터페이스를 구현합니다. 그러나, 그들 간에 차이가 있습니다.