Java集合

集合是指：可以传输任何类型，任意多个数据的容器。我们可以自定义容器，但是直接使用已经定义好的容器会加快我们编程的效率以及质量。 自定义容器： 1.数组容器（数组）： public class DataL{ private Object[] arr;// = new int[10];//创建一个数组，固定长度 private int size;//默认值为0,此时看成数组的索引值，标记了一个数组存值的位置 //无参的构造方法，调用有参的构造方法。默认值 public DataL(){//创建一个无参的构造方法，给这个字段赋值长度为10的数组 this(10);//调用有参的构造方法 } //当自己创建一个数组，那么就在此数组存值，不消耗CPU性能，有参的构造方法 public DataL(int length){//有参的构造方法，当对象传参时则创建一个初始化的数组，此数组长度就是传入的值 arr = new Object[length]; } //查看此时打印数组的长度，即已经传入了多少个值了 public int size(){//创建个方法，查看当前打印数组的长度 return size; } //创建一个方法，当数组的索引值等于长度时，则面临索引越界存值，会报错。所以此时则需要自增 //自动扩容 public void add(Object a){ if(size == arr.length){ Object[] temp =new Object[(size+1)2];//保证最小为1，当size为0的时候，那么此时temp数组的长度为1，扩容数为1.确保临时创建的数组是比原数组长的 System.arraycopy(arr, 0, temp, 0, size);//把arr的值全部放在temp中 arr = temp;//令temp数组重新赋值给arr* } arr[size++] = a;//如果这个数组的长度是够的，那么就自动赋值 } //数据的查找a.根据索引位置找数据 public Object getDataByIndex(int index){ if(index < 0 || index >size-1){//判断index在处在索引值范围内 throw new ArrayIndexOutOfBoundsException("你好，你所输入的数字不正确！"); } return arr[index]; } //数据的查找b.根据数据找第一次出现数据的索引值 public int getIndexByData(Object a){ for(int i = 0;i <= size-1;i++){ if (a.equals(arr[i])) { return i; } } return -1; } //数据的修改a.根据索引该数据 public void xiugai(int index,Object c){ if(index < 0 || index >size-1){//判断index在处在索引值范围内 throw new ArrayIndexOutOfBoundsException("你好，你所输入的数字不正确！"); } arr[index] = c;//将索引值为index的值更改为c } //数据的修改b.根据数据该数据 public void xiuggai(Object a,Object b){ for(int i = 0;i <= size - 1;i++){ if(a.equals(arr[i])){ arr[i] = b; } } } //数据删除a.删除该索引值所在位置的数据 public void shanchu(int index){//删除该索引值所在位置的值 if(index < 0 || index >size-1){//判断index在处在索引值范围内 throw new ArrayIndexOutOfBoundsException("你好，你所输入的数字不正确！"); } //将arr数组从index+1的索引值开始拷贝。因为此时要删除index索引值的数据，从后一个开始拷贝到同一个数组中。从后往前依次覆盖 System.arraycopy(arr, index+1, arr, index, size-1-index); //自减，因为最后一个没有值去覆盖，所以要去掉最后一个存储空间 size--; } //数据删除。如果需要删除第一次出现的数据，那么先遍历，然后找到现在这个数据的索引值，然后使用此索引值，删除此数据 public void shangchu(Object a){ for(int i = 0;i <= size-1;i++){ if (a.equals(arr[i])) {//求得要删除数据的索引值 System.arraycopy(arr, i+1, arr, i, size-1-i);//根据索引值去掉数据 break;//结束当层，不能使用return } } size--;//自减，使用完循环后必须使用 } //打印数组 @Override public String toString() {//覆写arr，使调用方法时，则打印出值,打印数组 //循环遍历数组，然后返回一个新的数组。String（创建一次对象打印一次）、StringBuilder（创建一个对象，打印多次）、StringBuffer（创建一个对象，打印多次） Object[] temp = new Object[size]; System.arraycopy(arr, 0, temp, 0, size);//arr老数组，0从0开始传，temp传到temp数组中，0从temp数组中的0的位置开始，size传size个。 //传size个就是将size就是arr的长度，此时temp的长度为size，所以直接将已经赋值的arr数组代入到temp数组中。 return "DataL [arr=" + Arrays.toString(temp) + "]";//返回的是这个数组,打印的也是这个数组 } } 2.自定义容器：（链表） public class Node { protected Node next; //指针域
public int data;//数据域
public Node( int data) {
this. data = data;
}
//显示此节点
public void display() {
System. out.print( data + " ");
}
} 接下来定义一个单链表，并实现相关方法： public class LinkList { public Node first; // 定义一个头结点 private int pos = 0;// 节点的位置 public LinkList() { this.first = null; } // 插入一个头节点 public void addFirstNode(int data) { Node node = new Node(data); node.next = first; first = node; } // 删除一个头结点,并返回头结点 public Node deleteFirstNode() { Node tempNode = first; first = tempNode.next; return tempNode; } // 在任意位置插入节点 在index的后面插入 public void add(int index, int data) { Node node = new Node(data); Node current = first; Node previous = first; while (pos != index) { previous = current; current = current.next; pos++; } node.next = current; previous.next = node; pos = 0; } // 删除任意位置的节点 public Node deleteByPos(int index) { Node current = first; Node previous = first; while (pos != index) { pos++; previous = current; current = current.next; } if (current == first) { first = first.next; } else { pos = 0; previous.next = current.next; } return current; } // 根据节点的data删除节点(仅仅删除第一个) public Node deleteByData(int data) { Node current = first; Node previous = first; // 记住上一个节点 while (current.data != data) { if (current.next == null) { return null; } previous = current; current = current.next; } if (current == first) { first = first.next; } else { previous.next = current.next; } return current; } // 显示出所有的节点信息 public void displayAllNodes() { Node current = first; while (current != null) { current.display(); current = current.next; } System.out.println(); } // 根据位置查找节点信息 public Node findByPos(int index) { Node current = first; if (pos != index) { current = current.next; pos++; } return current; } // 根据数据查找节点信息 public Node findByData(int data) { Node current = first; while (current.data != data) { if (current.next == null) return null; current = current.next; } return current; } }

最后我们可以通过测试类来做相关测试:
public class TestLinkList {
	public static void main(String[] args) {  
		LinkList linkList = new LinkList();  
		linkList.addFirstNode(20);  
		linkList.addFirstNode(21);  
		linkList.addFirstNode(19);  
		 //print19,21,20  
		linkList.add(1, 22); //print19,22,21,20  
		linkList.add(2, 23); //print19,22,23,21,20  
		linkList.add(3, 99); //print19,22,23,99,21,20  
	  //调用此方法会print 19,22,23,99,21,20 
		linkList.displayAllNodes();  
	}
}

Collection体系： List集合--可重复，有序： 1.ArrayList--基于数组 CRUD（增删改查）： //容器类 public class MyArrayList { //用来存放数据 private Object[] data =null; //用于计数 private int size ;// //使用者知道要存多少数据 public MyArrayList(int i) { data = new Object[i]; } // public MyArrayList() { this(10);// } //给使用者调用 /* 什么时候需要传参数 * 什么时候需要返回值 / public void add(Object object) { //判断是需要扩容 if (size>=data.length) { int i = (int)(data.length+data.length0.3+1); //1.重新创建一个数组 Object[] temp = new Object[i]; //2.拷贝数据 System.arraycopy(data, 0, temp, 0, size); //3.新的数组的地址给data data = temp; } data[size] = object; //执行完以后 计数器发生改变 size++; } //删除 public Object delete(int index) { if (index<0||index>size) { throw new ArrayIndexOutOfBoundsException("参数不合法！"); } Object obj = data[index]; System.arraycopy(data, index+1, data, index, size-index-1); //计数器要自减 size--; return obj; } @Override public String toString() { Object[] temp = new Object[size]; System.arraycopy(data, 0, temp, 0, size); return "MyArrayList [data=" + Arrays.toString(temp) + "]"; } } 2.LinkedList--基于链表 集合的遍历： public static void main(String[] args) { LinkedList list = new LinkedList(); list.add("A"); list.add("B"); list.add("C"); list.add("D"); list.offer("A"); list.offerFirst("二狗"); /** * 第一种方式 可以得到下标 / for (int i = 0; i < list.size(); i++) { / * 第一次：i = 0 size = 3 [B,C,D] * 第二次：i= 1 size=2 * 第三次：i= 2 / //System.out.println(list.remove(i)+"删除的元素"); //System.out.println(list.size()); System.out.println(list.get(i)); } System.out.println(list); /* * 第二种方式 增强for循环无法获取下标 / System.out.println("---------------------------"); for (Object object : list) { System.out.println(object); } System.out.println("------------迭代器---------------"); /* * 迭代器 * Iterable-->一个接口方法 Iterator<T> iterator() * Iterator<T> iterator() 返回一个在一组 T 类型的元素上进行迭代的迭代器。 * |-- boolean hasNext(); * |-- Object Next(); * |-- void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作） */ //得到一个 双向迭代器 ListIterator listIterator = list.listIterator(); //从左往右迭代 while (listIterator.hasNext()) { System.out.println(listIterator.next()); } //反向迭代 while (listIterator.hasPrevious()) { System.out.println(listIterator.previous()); } } } Set集合：不可重复，无序 1.HashSet hashCode与equals同时判定重复的标准 public class HashSetDemo4 { public static void main(String[] args) { HashSet hs = new HashSet(); hs.add(new Dog("zs", 18)); hs.add(new Dog("zs", 18)); hs.add(new Dog("zs", 19)); hs.add(new Dog("zz", 18)); System.out.println(hs.size()); System.out.println(hs); } } class Dog{ private String name ; private int age ; public Dog(String name, int age) { super(); this.name = name; this.age = age; } //建议使用提示生成 @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } //建议自己去写 @Override public boolean equals(Object obj) { //判断 obj 是否为 Dog的一个实例 if (obj instanceof Dog) { Dog p = (Dog) obj; //先比较年龄 if (p.age>this.age) { return false; }if (p.age<this.age) { return false; }else { //年龄相等 ，判断名字是否一样 if (this.name.equals(p.name)) { return true; } } } return false; } } 2.TreeSet：在Set集合中排序是不定（假象）的，只能通过自来实现排序的功能 ①自然排序 public class TreeSetDemo3 { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Animal("A",21)); ts.add(new Animal("B",22)); ts.add(new Animal("C",20)); ts.add(new Animal("A",21)); System.out.println(ts); } } class Animal implements Comparable{ private static final Object Person = null; private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Person(String name, int age) { super(); this.name = name; this.age = age; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } //谁调用这个方法，这个this就表示当前对象，即上一次对象。 //如果升序，那么大的值就向后排。 @Override public int compareTo(Object o) { if (o instanceof Person) { Person p = (Person)o; if (p.getAge()>this.getAge()) { return -1; }else if(p.getAge()<this.getAge()){ return 1; } } return 0; } } ②自定义排序： public class TreeSetDemo3 { public static void main(String[] args) { TreeSet ts = new TreeSet(new A()); ts.add(new Animal("何杰",21)); ts.add(new Animal("王雨",22)); ts.add(new Animal("狗狗",20)); ts.add(new Animal("何杰",21)); System.out.println(ts); } } //使用比较器,创建比较器 class A implements Comparator{ @Override public int compare(Object o1, Object o2) { if (o1 instanceof Animal && o2 instanceof Animal) { Animal a = (Animal)o1; Animal b = (Animal)o2; if(a.getAge()>b.getAge()){ return 1; }else if(a.getAge()<b.getAge()){ return -1; } } return 0; } } Map体系（映射）--存在Key集合与Value集合，一个Key值对应一个Value集合，Key值不能存在相同。 使用HashMap学习Map 1.添加值（put） public class MapTest { public static void main(String[] args) { HashMap map = new HashMap(); map.put("A", 1); map.put("B", 2); Object put = map.put("C", 3); map.put("D", 4); Object put2 = map.put("C", 5); System.out.println(put); System.out.println(put2);//打印覆盖上一个键的值 System.out.println(map); /*boolean containsKey(Object key) 如果此映射包含对于指定键的映射关系，则返回 true。 / boolean containsKey = map.containsKey("A"); System.out.println(containsKey); / boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。 */ boolean containsValue = map.containsValue(3);//已经被覆盖 System.out.println(containsValue); /void clear() 从此映射中移除所有映射关系。 清空映射中所有值/ map.clear(); System.out.println(map); } } 2.遍历Map中的值 public class MapTest { public static void main(String[] args) { HashMap map = new HashMap(); map.put("A", 1); map.put("B", 2); map.put("C", 3); map.put("D", 4); map.put("E", 5); /*Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set（实现了Iterable接口） 视图 */ Set entrySet = map.entrySet(); for (Object object : entrySet) {//object为Entry接口中的子类，Key和Value分别为集合，从中提取Key和Value。 Entry e = (Entry)object; System.out.println(e.getKey()+"---"+e.getValue()); } System.out.println("***********************************"); /*Set<K> keySet() 返回此映射中包含的键的 Set 视图 */ Set keySet = map.keySet(); for (Object object : keySet) { //object为Key，通过map.get()传入Key找出Value值 System.out.println(object + "---" +map.get(object)); } } }

转载于:https://my.oschina.net/u/4083606/blog/3029847