list集合增删改、查询三种方法、list与linked区别以及堆栈和队列、底层去重

1、list集合增删改

public class Demo1 {
	public static void main(String[] args) {
			List<String> list=new ArrayList<String>();
			//增加
			list.add("张三");
			list.add("李四");
			list.add("王五");
			System.out.println(list);
			//删除
			//方式1
			String r1 = list.remove(0);
			System.out.println(r1);
			System.out.println(list);
			
			//方式二
			boolean r2 = list.remove("李四");
			System.out.println(r2);
			System.out.println(list);
			
			//修改
			list.set(0, "老六");
			System.out.println(list);
}

2、查询方法，普通查询、增强for循环、迭代器

public class Demo1 {
	public static void main(String[] args) {
			List<String> list=new ArrayList<String>();
			
			//查询
			//重新增加元素
			list.add("张三");
			list.add("李四");
			list.add("王五");
			
			//方式1：for循环
			for (int i = 0; i < list.size(); i++) {
				System.out.println(list.get(i));
			}
			
			System.out.println("+++++++++++++++++++++++++++++++++++++");
			//方式二：增强for循环
			for (String i : list) {
				System.out.println(i);
			}
			
			System.out.println("+++++++++++++++++++++++++++++++++++++");
			//方式三：迭代器
			Iterator<String> iterator = list.iterator();
//			System.out.println(iterator.hasNext());	判断有没有下一个元素
//			System.out.println(iterator.next());	将下一个元素取出来
			while (iterator.hasNext()) {
				System.out.println(iterator.next());
				
			}
					
			
	}
}

此处迭代器，最开始的指向是空值，.hasNext,返回值为boolean类型，如果有下一个元素，返回的是true，也就是有下一个元素，然后.next将下一个取出来。如果没有值了，.hasNext将会返回false，那么就会停止。

3、list与linked区别

先上结论：arrayList特点：底层结构是数组，修改查询快，删除新增慢。

                linkedList特点：底层结构是链表，修改查询慢，删除新增快。

以下是数组结构的图画举例：

        

 以下是链表结构的图像举例：

 

4、堆栈和队列

先上结论：

        堆栈特点：先进后出 (先保存进的数据最后再打印出来)

        队列 特点：先进先出(先保存进的数据最先再打印出来)

package com.zking.listi;

import java.util.LinkedList;

/**
 * linkedList：如何去完成队列/堆栈开发
 * 				堆栈特点：先进后出
 * 				队列：先进先出
 * @author 78590
 *
 */
public class Demo2 {
public static void main(String[] args) {
	//队列
	DuiLie duilie =new DuiLie(new LinkedList<>());
	duilie.push("张三");
	duilie.push("李四");
	duilie.push("王五");
	System.out.println(duilie.pop());
	System.out.println(duilie.pop());
	System.out.println(duilie.pop());
	
	System.out.println("++++++++++++++++++++++++++++++++++++++++++");
	
	//堆栈
	DuiZhan duizhan=new DuiZhan(new LinkedList<>());
	duizhan.push("张三");
	duizhan.push("李四");
	duizhan.push("王五");
	System.out.println(duizhan.pop());
	System.out.println(duizhan.pop());
	System.out.println(duizhan.pop());
}
}
//队列，先进先出
class DuiLie{
	private LinkedList<String> la;

	public DuiLie(LinkedList<String> la) {
		super();
		this.la = la;
	}
	
	public void push(String a) {
		la.add(a);
	}
	public String pop() {
		return la.remove();
	}
}
//堆栈，先进后出
class DuiZhan{
	private LinkedList<String> la;

	public DuiZhan(LinkedList<String> la) {
		super();
		this.la = la;
	}
	
	public void push(String a) {
		la.add(a);
	}
	public String pop() {
		return la.removeLast();
	}
}

5、list底层去重

首先我们先上常规方法

public class Demo3 {
	//常规作法
public static void main(String[] args) {
//	List<String> la=new ArrayList<String>();
//	la.add("张三");
//	la.add("李四");
//	la.add("王五");
//	la.add("王五");
//	System.out.println(la);
//	List<String> newLa=new ArrayList<>();
//	for (String s : la) {
//		if(!newLa.contains(s)) {	//如果包含该元素我就加入到新集合中，此处取反
//			newLa.add(s);
//		}
//	}
//	System.out.println(newLa);
        }
}

以上方法我是用String类型来进行比较的，也是常规方法，Sting

类型比较是否是同样的数据，都是放在常量区进行比较的，所以可以去重成功,但是我们看下面这种

import java.util.ArrayList;
import java.util.List;

/**
 * list去重
 * 		底层去重是依靠元素本身的equals方法
 * @author 78590
 *
 */
public class Demo3 {
	//常规作法
public static void main(String[] args) {
	
	List<Person> la=new ArrayList<>();
	la.add(new Person("张三", 20));
	la.add(new Person("李四", 21));
	la.add(new Person("王五", 22));
	la.add(new Person("王五", 22));
	System.out.println(la);
	//常规方法
	List<Person> newList=new ArrayList<>();
	for (Person s : la) {
		if(!newList.contains(s)) {
			newList.add(s);
		}
	}
	System.out.println(newList);
}
}

class Person{
	private String name;
	private Integer age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((age == null) ? 0 : age.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age == null) {
			if (other.age != null)
				return false;
		} else if (!age.equals(other.age))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
}

此处我建了一个人类，里面有姓名和年龄，如果这时候再用常规方法，是去重不了的，因为每new一个数据，就好比这个数据有了一个身份证一样，每个身份证都是不一样的，所以判断的两个王五虽然是一样的，但是身份证不一样，所以判断为不同数据，去重不了。

解决方法，在新建的”人“类中，重写equals方法，上述图片中最下面一部分的代码，此时的底层去重是依靠元素本身的equals方法进行去重，所以才可以去重成功。