Java中的集合框架(ArrayList LinkedList HashSet)

了解Java集合框架体系结构

集合：是一个存储批量数据的地方
接口有三大类：Colletions Arrays Set
集合框架体系如图所示

使用ArrayList存储和获取数据

创建集合的命令：

package com.xxx.demo;

import java.util.ArrayList;

public class Demo {
	public static void main(String[] args) {
		/** 创建ArrayList集合 */
		ArrayList<Object> arrayList = new ArrayList<>();

	}

}

这里Object是祖宗类，也就是什么类型都可以写进去，而集合石泛型的特点，它是用来约束/声明集合的数据类型的
泛型必须是引用数据类型，如果是存储基本数据类型值，则必须将其转为对应引用数据类型(包装类型)。
byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean
下面说一下常用的语法：
增加元素

list.add(可以说任何类型);

修改元素

list.set(index,element);  // 是根据下标修改某一个值

删除元素

list.remove(下标);  // 使用下标来删除  也可以用对象删除

清空元素

list.clear();

小demo演示一下

package com.arraylist.demo;

import java.util.*;

/**
 * 
 * @author DELL ArraryList：动态数组 (底层就是一个数组来存储数据) 
 * 特点1：存储的是Object类型的元素，所以任何数据都可以装进去
 * 特点2：长度是可以动态改变的，如果长度不够，集合本身会动态自动扩容 
 * 特点3：存储元素是有序的，所以可以通过下标来访问
 * 特点4：可以添加重复元素，它允许重复 集合：是一个存储批量数据的地方 只需要弄清楚集合的增删改查就可以了
 */
public class Demo {
	public static void main(String[] args) {
		/**
		 * 实例化一个arraylist ArrayList list = new ArrayList(); 但是一般不这么new创建 规范的如下
		 */
		List list = new ArrayList();
		/**
		 * 增加元素 可以说任何类型的，比如String类型字符串 int类型的整数 double类型的小数
		 */
		list.add("李逍遥1");
		list.add("李逍遥2");
		list.add(123);
		list.add(5.20);
		/**
		 * 修改元素 使用set方法，是根据下标修改某一个值
		 */
		list.set(0, "逍遥哥哥");
		/**
		 * 查找元素 装进去，会帮你封装成对象，你读出来需要把对象转换成字符串 所以要有类型转换
		 */
		String name = (String) list.get(0);
		System.out.println(name);
		/** 看数组的长度 */

		System.out.println(list.size());
		/** 删除元素 使用下标来删除 也可以用对象删除 比如删除李逍遥1 */
		// list.remove(0);
		// list.remove("李逍遥1");
		/// ** 清空元素 */
		// list.clear();
		/** 查找元素 */
		System.out.println("查找到的下标为：" + list.indexOf("逍遥哥哥"));
		/// ** 循环遍历所有 显示出来 有3种方法 */
		System.out.println("=============");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("=============");
		for (Object obj : list) {
			System.out.println(obj);
		}
	}
}

一些来自于ArrayList父级接口：

toArray() 转换为数组

clear() 清除所有的元素

isEmpty() 判断是否为空集合  /  list.size() == 0

iterator() 迭代器

使用LinkedList存取数据

底层是链表

创建集合的语法

LinkedList linkedList = new LinkedList<>();

基本上ArrayList里面拥有的，LinkedList接口的API也拥有

1. void addFirst(Object obj);  将元素添加到第一个
2. void addLast(Object obj);  将元素添加到最后一个
3. Object getFirst();  获取第一个  
4. Object getLast();  获取最后一个
5. Object removeFirst(); 删除第一个
6. Object removeLast();  删除最后一个

下面看个小demo

package com.linkedlist.demo;

import java.util.LinkedList;
/**
 * 
 * @author DELL
 *	LinkedList的用法跟ArrayList的用法基本上都是一样的
 *	LinkedList拥有ArrayList没有的扩展
 *	使用的时候就要自己创建自己的对象了
 *	LinkedList list = new LinkedList();
 *	特点1：有序，可重复，可以通过下标来访问
 *	
 */
public class Demo {
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		/** 在最前面加 */
		//list.addFirst(e);
		/** 删除第一个元素 */
		//list.removeFirst();
		/** 删除最后一个元素 */
		//list.removeLast();
		
		list.add("赵灵儿");
		list.add("林月如");
		list.add("李逍遥");
		list.add(33);
		//list.remove("赵灵儿");
		list.set(0, "灵儿");
		
		/** 获取下标为0的内容 */
		System.out.println(list.get(0));
		/**获取这个对象数组的长度 */
		System.out.println(list.size());
		/** 判断是否存在，返回值为true，或者为false */
		System.out.println(list.contains("李逍遥"));
		
	}
}

---

package com.linkedlist.demo;

import java.util.LinkedList;
/**
 * @author DELL
 * 集合里面也可以装对象
 */
public class Demo1 {
	public static void main(String[] args) {
		/** 构建一个LinkedList对象 */
		LinkedList list = new LinkedList();
		/** 增加对象 */
		//list.add(new Student(1, "张三"));
		//list.add(new Student(2, "李四"));
		//list.add(new Student(3, "王五"));
		list.add("张三");
		list.add("李四");
		list.add("王五");
		/** 在最前面添加 */
		list.addFirst("周六");
		/** 在最后添加 */
		list.addLast("赵六");
		/** 又添加最前面 */
		list.addFirst("田七");
		/** 删除指定的 */
		list.remove("田七");
		/** 删除第一个 */
		list.removeFirst();
		/** 删除最后一个 */
		list.removeLast();
		
		
		
		for(Object obj : list) {
			System.out.println(obj);
		}
		
		
		/** 需要转换类型 */
		//Student stu = (Student)list.get(0);
		//System.out.println(stu.getName());
	}
}

---

这里说个小知识：了解ArrayList和LinkedList的区别ArrayList：底层是数组结构，所以因为是数组，则拥有索引，在遍历或随机查找时比较快，但是又因为是数组，数组长度不可变，每一次增删都是要创建新的数组，比较慢。

LinkedList：底层是链表结构，链表结构存储每一个元素由两部分组成，数据域和指针域，它没有索引。多个元素之间，通过指针域指向连接。 因为没有索引，所以查找比较慢，但是因为是链表所以在增删时只需要切换指针指向即可(尤其首尾更快)。

---

Set集合的遍历

public class Demo {

	public static void main(String[] args) {

		// List系列集合  ArrayList  LinkedList
		List<String> list = Arrays.asList("hehe","xixi","heihei","haha");
		
		// 创建Set集合
		Set<String> set = new HashSet<>();
		set.add("hehe");
		set.add("xixi");
		set.add("meme");
		
		// 1.普通for循环   利用索引来遍历
		/*for (int i = 0; i < list.size(); i++) {
			String str = list.get(i);
			System.out.println(str);
		}*/
		
		// 2.增强for循环【推荐】  遍历出每一个元素值
		/*for(String str : list) {
			System.out.println(str);
		}
		System.out.println("-------------------");
		for (String str : set) {
			System.out.println(str);
		}*/
		
		// 3.迭代器
		Iterator<String> iterator = list.iterator();
		// iterator.hasNext() 判断是否有下一个元素
		// iterator.next() 获取下一个元素
		
		while(iterator.hasNext()) {
			String value = iterator.next();
			System.out.println(value);
		}
		System.out.println("---------------------");
		Iterator<String> setIterator = set.iterator();
		while(setIterator.hasNext()) {
			String str = setIterator.next();
			System.out.println(str);
		}
	}
}

HashSet的特点

• 1.不可重复
• 2.无需，不能通过下标访问
• 迭代：遍历的意思
• 迭代器：用于遍历实现了Iterator接口的集合
• 1.hasNext() 表示是否还有下一个元素
• 2.next()表示取出下一个元素
• 3.HashSet底层实现结构，就是HashMap