Java的数组和集合的精华-清晰明了

Java的数组和集合的精华

数据的存储分类

• **短期存储：**一旦计算机关闭,存储的内容会被立刻释放- - - -变量,对象,数组,集合。
• **长期存储：**直接存储在磁盘上,可以长久的保存,数据不会随着计算机的关闭而消失.- - - -.mp4,.mp4,.txt,.doc,jpg,png。

数组

• **定义：**可以存储不同类型的多个数据,数据类型可以是简单数据类型也可以引用数据类型。
• **缺点：**创建的是一个定值,只能存储固定长度的数据,一旦存满了,就不能再继续存储。
• 定义：

	public class All {
		public static void main(String[] args) {
			int[] arr = new int[5];
			int[] arr1 = {1, 2, 3, 4, 5};
			int[] arr2 = new int[]{1, 2, 3, 4, 5};
		}
	}

• 遍历：

	public class All {
		public static void main(String[] args) {
			System.out.println(arr);//打的是数组的地址
			for (int i = 0; i < arr1.length; i++) {//打印的是元素
				System.out.println(arr1[i]);
			}
			for (int i : arr2) {//打印的是元素
				System.out.println(i);
			}
		}
	}

（重点）集合

1、Collection：- - - 接口

1. Collection的使用和其中的方法的使用：

public static void main(String[] args) {
		Collection collection = new ArrayList<>();
		//Collection中定义是整个集合体系最共性的方法:
		//1.添加：
		//boolean add(Object o) 
		collection.add("java");
		collection.add("php");
		collection.add("iOS");
		System.out.println(collection);
		//boolean addAll(Collection  c) 
		Collection collection1 = new ArrayList<>();
		collection1.add("python");
		collection1.add("html");
		collection.addAll(collection1);
		System.out.println(collection);
		//2.删除:
	    //boolean remove(Object o)  
		//collection.remove("html");
		//System.out.println(collection);
	    //boolean removeAll(Collection<?> c)--删除定义的一批元素.但是collection里面不一定包含collection1的所有内容.
		//collection.removeAll(collection1);
		//System.out.println(collection);
	    //void clear()--空集合 != null
		//collection.clear();
		//System.out.println(collection);
		//3.判断:
		//boolean contains(Object o) --是否包含一个元素
		System.out.println(collection.contains("java"));//true
		//boolean containsAll(Collection<?> c)--是否包含多个元素
		//boolean isEmpty() //判断集合是否为空
		System.out.println(collection.isEmpty());//false
		//boolean equals(Object o) --比较的是集合的内容
		Collection collection2 = new ArrayList<>();
		collection2.addAll(collection);
		System.out.println(collection.equals(collection2));//true
		//4.获取：
		//Iterator<E> iterator() //获取集合中的对象
		test(collection);
		//int size() //获取集合中对象的个数
		System.out.println(collection.size());
		//5.集合变数组：
		//Object[] toArray()--当我们希望集合的长度固定下来的时候,就转数组
		Object[] objects = collection.toArray();
		for (Object object : objects) {
			System.out.println(object);
		}
	}

• Iterator： 遍历的时候用迭代器（Iterator）来遍历，Iterator获取集合中的对象,对集合实现遍历。
  1. **boolean hasnext()?*判断当前的位置是否存在元素,存在返回true,不存在返回false。
  2. **Object next()?*将当前位置的元素返回,并且指向当前位置的指针指向下一个位置。
  3. 遍历过程：

	public static void test(Collection collection){
			//1.获取迭代器对象
			Iterator iterator =  collection.iterator();
			//2.通过方法实现遍历
			while (iterator.hasNext()) {
				Object object =  iterator.next();
				System.out.println("元素:"+object);
			}
			//注意点:
			//1.直接再次使用第一次的iterator进行遍历,遍历失败.因为当前的指针已经指向了集合的最后.
			//再次使用hasnext会直接返回false.所以如果想再次遍历,要重新获取迭代器对象.
			while (iterator.hasNext()) {
				Object object =  iterator.next();
				System.out.println("元素1:"+object);
			}
			//2.集合可以同时存储不同类型的数据
			collection.add(4);//存储的是:new Integer(4)--自动装箱
			//3.再次遍历--当集合中同时存在不同类型的数据时,需要进行容错处理和向下转型.
			Iterator iterator1 =  collection.iterator();
			while (iterator1.hasNext()) {
				Object object =  iterator1.next();
				if (!(object instanceof String)) {
					throw new ClassCastException();//类型转化异常
				}
				//向下转型
				String string = (String)object;
				System.out.println(string.length());
			}
		}

• List - - - 接口
  1. **解释：**存储的数据是存的是有序的（元素的顺序与添加元素的顺序相同），可以重复的
  2. 分类：
     • ArrayList - - - 类： 底层的数据结构是数组,线程不安全的.特点:查找速度快,添加删除速度慢。
     • Vector - - - 类： 底层的数据结构是数组,线程安全的.特点:查找速度快,添加删除速度慢。
     • **LinkedList - - - 类: ** 底层是链表,线程不安全的.特点:查找速度慢,添加删除速度快。
  3. List：

	public static void main(String[] args) {
			List list = new ArrayList();
			//* List：特有方法，可以操作下标
			//1.增：
			//void add(int index, E element) 
			//boolean addAll(int index, Collection<? extends E> c) 
	        list.add("java");
	        list.add("java1");
	        list.add("java2");
	        list.add(0, "php");
	        list.add("html");
	        System.out.println(list);
			//2.删
			//E remove(int index) 
	        
	        System.out.println(list.remove(0));
			//3.改
		    //E set(int index, E element)
	         list.set(0, "c");
	         System.out.println(list);
			//4.查
		     //ListIterator<E> listIterator() 
	         test(list);
		     //返回此列表元素的列表迭代器（按适当顺序）。 
		     //ListIterator<E> listIterator(int index) 
		     //List<E> subList(int fromIndex, int toIndex) 包含开头不包含结尾
	         List sub = list.subList(1, 3);
	         System.out.println(sub);
		     //E get(int index) 
	         System.out.println(list.get(0));
			     
			//5.删除全部对象
	        // list.clear();
	}

4.  **Iterator：** 遍历的时候用迭代器（Iterator）来遍历，Iterator获取集合中的对象,对集合实现遍历。
	1. **注意点1：** 在使用迭代器期间,使用list的删除方法直接删除元素（list.remove("java1")）,有可能发生错误,所以不要这样做。
	2. **注意点2：** 在使用迭代器期间,要想删除元素使用迭代器自带的方法进行删除（iterator.remove()）。
	3. **注意点3：** 他的remove,add,set方法尽量不要同时使用。
	4. **遍历：**

	    public static void test(List list){
	    	ListIterator iterator = list.listIterator();
	    	//从左到右遍历
	    	while (iterator.hasNext()) {
				Object object =  iterator.next();
				System.out.println("从左到右:"+object);
			}
	    	//从右到左
	    	while (iterator.hasPrevious()) {
				Object object = iterator.previous();
				System.out.println("从右到左:"+object);
			}
	    	//注意事项:
	    	while (iterator.hasNext()) {
				Object object =  iterator.next();
				System.out.println("从左到右:"+object);
				//需求:将java1删除
				if (object.equals("java1")) {
					//在使用迭代器期间,使用list的删除方法直接删除元素,有可能发生错误,所以不要这样做
					//list.remove("java1");
					//使用迭代器自带的方法进行删除
					//注意:他的remove,add,set方法尽量不要同时使用.
					iterator.remove();
					
				}
			}
	    	System.out.println(list);
	    }

5. **vector：**
	* 定义：边长的数组
	* 使用方法：

public static void main(String[] args) {
		Vector<String> vector = new Vector<>();
		vector.add("java1");
		vector.add("java2");
		vector.add("java3");
		vector.add("java4");
		vector.add("java5");
		
		//遍历--枚举器
		//获取枚举器
		Enumeration<String> enumeration = vector.elements();
		//遍历
		while (enumeration.hasMoreElements()) {
			String string = (String) enumeration.nextElement();
			System.out.println(string);
		}
	}

6. **ArrayList：**
	* 用一个例子讲解：因为是可以存重复，现在要求存不重复的数据（存的是简单的数据类型）。
		1. 代码：

	public static void main(String[] args) {
			ArrayList<String> list = new ArrayList<>();
			list.add("java1");//第一个
			list.add("java2");//第二个
			list.add("java2");//第三个
			list.add("java3");
			System.out.println(list);
			//在创建一个ArrayList对象作为存储去重后的数据的集合
			ArrayList<String> list1 = new ArrayList<>();
			//遍历原来的集合
			Iterator<String> iterator = list.iterator();
			while (iterator.hasNext()) {
				Object object =  iterator.next();
				/*
				 * 如果判断成立,说明list1中不包含当前的元素
				 * 工作原理:当添加元素时,会让当前的元素与集合中已有的元素通过equels方法进行一一比较.过程中
				 * 只要有一次返回true,停止比较.让整个的contains方法返回true.只有所有的比较都返回false,最终
				 * 才会返回false 
				 * 实例:添加第三个元素的时候,调用equals方法的过程
				 * 第三元素.equals("java1") = false     第三元素.equals("java2") = true  停止比较
				 * 
				 */
				if (!list1.contains(object)) {
					list1.add((String) object);
				}
			}
			System.out.println(list1);
		} 

		2. 解释：
			* 用contains函数进行比较
			* 添加元素时,会让当前的元素与集合中已有的元素通过equels方法进行一一比较.过程中只要有一次返回true,停止比较.让整个的contains方法返回true.只有所有的比较都返回false,最终才会返回false。

	* 当存的是引用数据类型的时候，判断不能添加重复的数据。
		1. 代码：

	class Person {
			String name;
			int age;
		
			public Person(String name, int age) {
				super();
				this.name = name;
				this.age = age;
			}
		
			@Override
			public String toString() {
				return "Person [name=" + name + ", age=" + age + "]";
			}
		
			// 重写equals方法---按照自己的规则进行比较
			// 按照姓名和年龄比较,只要姓名和年龄相同就认为是一个人
			@Override
			public boolean equals(Object obj) {
				if (!(obj instanceof Person)) {
					throw new ClassCastException();
				}
				// 向下转型
				Person person = (Person) obj;
				return age == person.age && name.equals(person.name);
			}
	}

		*

		public class Demo5 {
		
			public static void main(String[] args) {
				ArrayList<Person> list = new ArrayList<>();
				list.add(new Person("bingbing", 18));// 第一个
				list.add(new Person("bingbing1", 20));// 第二个
				list.add(new Person("bingbing", 18));// 第三个
				list.add(new Person("bingbing2", 40));
				System.out.println(list);
		
				// 在创建一个ArrayList对象作为存储去重后的数据的集合
				ArrayList<Person> list1 = new ArrayList<>();
				// 遍历原来的集合
				Iterator<Person> iterator = list.iterator();
				while (iterator.hasNext()) {
					Object object = iterator.next();
					/*
					 * 如果判断成立,说明list1中不包含当前的元素
					 * 工作原理:当添加元素时,会让当前的元素与集合中已有的元素通过equels方法进行一一比较.过程中
					 * 只要有一次返回true,停止比较.让整个的contains方法返回true.只有所有的比较都返回false,最终
					 * 才会返回false
					 * 
					 * 实例:添加第三个元素的时候,调用equals方法的过程
					 * 第三元素.equals(第一个元素) = true     停止比较
					 * 
					 */
					if (!list1.contains(object)) {
						list1.add((Person) object);
					}
				}
				System.out.println(list1);
			}
		}

		2. 解释：
			* 在Person类中需要重写equals方法，让其比较规则从原来比较一个简单类型的东数据，变成比较多个数据。
			* 使用方法在上面的例子里面有了明确的解释。
7. **LinkList:**
	* 解释： LinkList是链表数据，他的好处是能够让存储的内存不是连续的，特点:查找速度慢,添加删除速度快。
	* 具体使用代码：

	public static void main(String[] args) {
			// 特有的方法：
			LinkedList<String> linkedList = new LinkedList<>();
			// addFirst()//始终在首位添加
			// addLast()//始终在末尾添加
			linkedList.addFirst("java");
			linkedList.addLast("php");
			;
			linkedList.addFirst("iOS");
			linkedList.add("html");
			linkedList.add(1, "python");
			System.out.println(linkedList);
			// getFirst()//获取的对象不存在会发生异常 NoSuchElementException
			// getLast()
			// linkedList.clear();
			// System.out.println(linkedList.getFirst());
			// removeFirst()//删除的对象不存在会发生异常
			// removeLast()
			System.out.println(linkedList.removeFirst());
	
			LinkedList<String> linkedList1 = new LinkedList<>();
			// 从jdk1.6开始出现以下方法
			// offerFirst()
			// offerLast()
			linkedList1.offerFirst("java");
			linkedList1.offerLast("php");
			// peekFirst()//获取的对象不存在会返回null
			// peekLast()
			linkedList1.clear();
			System.out.println(linkedList1.peekFirst());
			// pollFirst()//删除的对象不存在会返回null
			// pollLast()
			System.out.println(linkedList1.pollFirst());
		}

说明:关于set和Map的讲解在我的另一篇名叫《集合Set和Map的讲解》的博客，感兴趣的朋友可以去了解一下，谢谢！