FilesExpand file tree

 master

/

DynamicArray.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

158 lines (113 loc) · 3.78 KB

 master

/

DynamicArray.java

Top

File metadata and controls

• Code
• Blame

158 lines (113 loc) · 3.78 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

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

package DataStructures.DynamicArray;

import java.util.Arrays;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

import java.util.NoSuchElementException;

import java.util.Objects;

import java.util.function.Consumer;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

public class DynamicArray<E> implements Iterable<E> {

private int capacity = 10;

private int size = 0;

private Object[] elements;

public DynamicArray(final int capacity) {

this.capacity = capacity;

this.elements = new Object[this.capacity];

}

public DynamicArray() {

this.elements = new Object[this.capacity];

}

public int newCapacity() {

this.capacity <<= 1;

return this.capacity;

}

public void add(final E element) {

if (this.size == this.elements.length)

this.elements = Arrays.copyOf(this.elements, newCapacity());

this.elements[this.size] = element;

size++;

}

public void put(final int index, E element) {

// Objects.checkIndex(index, this.size);

this.elements[index] = element;

}

public E get(final int index) {

return getElement(index);

}

public E remove(final int index) {

final E oldElement = getElement(index);

fastRemove(this.elements, index);

return oldElement;

}

public int size() {

return this.size;

}

public boolean isEmpty() {

return this.size == 0;

}

public Stream<E> stream() {

return StreamSupport.stream(spliterator(), false);

}

private void fastRemove(final Object[] elements, final int index) {

final int newSize = this.size - 1;

if (newSize > index)

System.arraycopy(elements, index + 1, elements, index, newSize - index);

elements[this.size = newSize] = null;

}

private E getElement(final int index) {

// Objects.checkIndex(index, this.size);

return (E) this.elements[index];

}

@Override

public String toString() {

return Arrays.toString(Arrays.stream(this.elements).filter(Objects::nonNull).toArray());

}

@Override

public Iterator iterator() {

return new DynamicArrayIterator();

}

private class DynamicArrayIterator implements Iterator<E> {

private int cursor;

@Override

public boolean hasNext() {

return this.cursor != size;

}

@Override

public E next() {

if (this.cursor > DynamicArray.this.size) throw new NoSuchElementException();

if (this.cursor > DynamicArray.this.elements.length) throw new ConcurrentModificationException();

final E element = DynamicArray.this.getElement(this.cursor);

this.cursor++;

return element;

}

@Override

public void remove() {

if (this.cursor < 0) throw new IllegalStateException();

DynamicArray.this.remove(this.cursor);

this.cursor--;

}

@Override

public void forEachRemaining(Consumer<? super E> action) {

Objects.requireNonNull(action);

for (int i = 0; i < DynamicArray.this.size; i++) {

action.accept(DynamicArray.this.getElement(i));

}

}

}

public static void main(String[] args) {

DynamicArray<String> names = new DynamicArray<>();

names.add("Peubes");

names.add("Marley");

for (String name : names) {

System.out.println(name);

}

names.stream().forEach(System.out::println);

System.out.println(names);

System.out.println(names.size());

names.remove(0);

for (String name : names) {

System.out.println(name);

}

}

}