FilesExpand file tree

 master

/

Lists.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

126 lines (125 loc) · 4.09 KB

 master

/

Lists.java

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

126 lines (125 loc) · 4.09 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

//: containers/Lists.java

package containers; /* Added by Eclipse.py */

// Things you can do with Lists.

import java.util.*;

import net.mindview.util.*;

import static net.mindview.util.Print.*;

public class Lists {

private static boolean b;

private static String s;

private static int i;

private static Iterator<String> it;

private static ListIterator<String> lit;

public static void basicTest(List<String> a) {

a.add(1, "x"); // Add at location 1

a.add("x"); // Add at end

// Add a collection:

a.addAll(Countries.names(25));

// Add a collection starting at location 3:

a.addAll(3, Countries.names(25));

b = a.contains("1"); // Is it in there?

// Is the entire collection in there?

b = a.containsAll(Countries.names(25));

// Lists allow random access, which is cheap

// for ArrayList, expensive for LinkedList:

s = a.get(1); // Get (typed) object at location 1

i = a.indexOf("1"); // Tell index of object

b = a.isEmpty(); // Any elements inside?

it = a.iterator(); // Ordinary Iterator

lit = a.listIterator(); // ListIterator

lit = a.listIterator(3); // Start at loc 3

i = a.lastIndexOf("1"); // Last match

a.remove(1); // Remove location 1

a.remove("3"); // Remove this object

a.set(1, "y"); // Set location 1 to "y"

// Keep everything that's in the argument

// (the intersection of the two sets):

a.retainAll(Countries.names(25));

// Remove everything that's in the argument:

a.removeAll(Countries.names(25));

i = a.size(); // How big is it?

a.clear(); // Remove all elements

}

public static void iterMotion(List<String> a) {

ListIterator<String> it = a.listIterator();

b = it.hasNext();

b = it.hasPrevious();

s = it.next();

i = it.nextIndex();

s = it.previous();

i = it.previousIndex();

}

public static void iterManipulation(List<String> a) {

ListIterator<String> it = a.listIterator();

it.add("47");

// Must move to an element after add():

it.next();

// Remove the element after the newly produced one:

it.remove();

// Must move to an element after remove():

it.next();

// Change the element after the deleted one:

it.set("47");

}

public static void testVisual(List<String> a) {

print(a);

List<String> b = Countries.names(25);

print("b = " + b);

a.addAll(b);

a.addAll(b);

print(a);

// Insert, remove, and replace elements

// using a ListIterator:

ListIterator<String> x = a.listIterator(a.size()/2);

x.add("one");

print(a);

print(x.next());

x.remove();

print(x.next());

x.set("47");

print(a);

// Traverse the list backwards:

x = a.listIterator(a.size());

while(x.hasPrevious())

printnb(x.previous() + " ");

print();

print("testVisual finished");

}

// There are some things that only LinkedLists can do:

public static void testLinkedList() {

LinkedList<String> ll = new LinkedList<String>();

ll.addAll(Countries.names(25));

print(ll);

// Treat it like a stack, pushing:

ll.addFirst("one");

ll.addFirst("two");

print(ll);

// Like "peeking" at the top of a stack:

print(ll.getFirst());

// Like popping a stack:

print(ll.removeFirst());

print(ll.removeFirst());

// Treat it like a queue, pulling elements

// off the tail end:

print(ll.removeLast());

print(ll);

}

public static void main(String[] args) {

// Make and fill a new list each time:

basicTest(

new LinkedList<String>(Countries.names(25)));

basicTest(

new ArrayList<String>(Countries.names(25)));

iterMotion(

new LinkedList<String>(Countries.names(25)));

iterMotion(

new ArrayList<String>(Countries.names(25)));

iterManipulation(

new LinkedList<String>(Countries.names(25)));

iterManipulation(

new ArrayList<String>(Countries.names(25)));

testVisual(

new LinkedList<String>(Countries.names(25)));

testLinkedList();

}

} /* (Execute to see output) *///:~