Java学习-第17天

最新推荐文章于 2022-07-29 16:02:37 发布

sec_90

最新推荐文章于 2022-07-29 16:02:37 发布

阅读量56

点赞数

文章标签： java 链表数据结构

本文链接：https://blog.csdn.net/sec_90/article/details/122590666

版权

package _01_Collection;

import java.util.ArrayList;
import java.util.LinkedList;

/**
 * LinkedList : 底层是一个双向链表,因为不是连续存储,
 * 
 * 只是能够找到下一个元素的地址而已,所以进行添加和删除操作效率较高
 * 
 * 但是 查询效率较低,因为只能从第一个挨个找
 * 
 * @author SEC90
 * @Date 2022年1月19日 下午2:11:46
 */
public class Collection_01_LinkedList {
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		// ArrayList list = new ArrayList();
		// 添加 到尾部
		list.add(1);
		list.add(11);
		list.add(12);
		list.add(13);
		// 添加到指定位置
		// list.add(index, element);
		// 添加到头部
		// list.push(e);
		// list.addFirst(e);
		// 尾部添加
		// list.addLast(e);
		// 个数
		System.out.println(list.size());
		// 是否为空
		System.out.println(list.isEmpty());
		// 根据下标删除
		list.remove(0);
		// 根据数据删除
		list.remove(new Integer(11));
		// 清空
		list.clear();
		// 更改
		list.set(2, 111);
		// 获取
		list.get(2);
		// 遍历
		for (Object object : list) {

		}
	}
}

package _01_Collection;

import java.util.LinkedList;

public class Collection_02_LinkedList {
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		list.add("q");
		list.add("w");
		list.add("e");
		list.add("r"); // x = w
		System.out.println(list.get(6));
		list.remove(3);
	}
}

package _01_Collection;

import java.util.ArrayList;
import java.util.LinkedList;

public class Collection_03_Test {
	public static void main(String[] args) {
		// 100W条数据为例
		// 尾部添加
		long startTime = System.currentTimeMillis();
		// addToArrayList();
		pushToArrayList();
		long endTime = System.currentTimeMillis();
		System.out.println("ArrayList添加完成,耗时 : " + (endTime - startTime));
		startTime = System.currentTimeMillis();
		// addToLinkedList();
		pushToLinkedList();
		endTime = System.currentTimeMillis();
		System.out.println("LinkedList添加完成,耗时 : " + (endTime - startTime));

		// 尾部添加 100W ArrayList 29 LinkedList 169
		// 首部添加 10W ArrayList 599 LinkedList 10
	}

	public static void pushToArrayList() {
		ArrayList list = new ArrayList();
		for (int i = 1; i <= 100000; i++) {
			list.add(0, i);
		}
	}

	public static void pushToLinkedList() {
		LinkedList list = new LinkedList();
		for (int i = 1; i <= 100000; i++) {
			list.addFirst(i);
		}
	}

	public static void addToArrayList() {
		ArrayList list = new ArrayList();
		for (int i = 1; i <= 1000000; i++) {
			list.add(i);
		}
	}

	public static void addToLinkedList() {
		LinkedList list = new LinkedList();
		for (int i = 1; i <= 1000000; i++) {
			list.add(i);
		}
	}
}

package _01_Collection;

import java.util.Set;
import java.util.TreeSet;

/**
 * Set特性 无序且不可重复,无序指的是添加顺序和取出顺序不保证一致
 * 
 * HashSet :  底层是散列表
 * 
 * TreeSet : 底层是红黑树,添加的元素必须按照一定的格式进行排序
 * 		数字 : 默认从小到大
 * 		字符串 : 按每位ASCII码进行排序
 * 		日期 : 自然日期,昨天今天明天...
 * 
 *	使用TreeSet的时候,元素必须实现了Comparable接口,因为在添加的时候,会自动调用该接口的compareTo方法进行比较
 *		添加字符串,数字,日期的时候,会进行自动排序,是因为Integer,String,Date都实现了该接口和该方法
 *	如果我们要存储自定类型的时候,就需要让该类去实现对应的接口和方法才能进行存储
 * 
 * @author SEC90
 * @Date 2022年1月19日 下午3:36:22
 */
public class Collection_04_Set_01 {
	public static void main(String[] args) {
		// 创建对象
		TreeSet set = new TreeSet();
		// 添加
		set.add(1);
		set.add(2);
		// 因为treeSet必须保证元素有序,也就意味着元素类型必须统一
		// 不统一就没有可比性,就不能排序
		// set.add("xxx");
		set.add(22);
		set.add(12);
		set.add(24);
		// 不可重复,如果重复则不添加
		set.add(12);
		System.out.println(set.size());
		System.out.println(set);
		// 根据内容删除, 不能根据索引删除,因为没有索引
		set.remove(22);
		// 遍历
		for (Object object : set) {
			System.out.println(object);
		}
		
		set = new TreeSet();
		// 每一位ASCII进行比较
		set.add("aadddd");
		set.add("aa");
		set.add("acadas");
		set.add("caa");
		set.add("d");
		// a,aa,aadddd,acadas,caa,d
		System.out.println(set);
		
		set = new TreeSet();
		set.add("1");
		set.add("2");
		set.add("3");
		set.add("4");
		set.add("5");
		set.add("6");
		set.add("7");
		set.add("8");
		set.add("9");
		set.add("10");
		// [1, 10, 2, 3, 4, 5, 6, 7, 8, 9]
		System.out.println(set);
	}
}

package _01_Collection;

import java.util.TreeSet;

/**
 *  *	使用TreeSet的时候,元素必须实现了Comparable接口,因为在添加的时候,会自动调用该接口的compareTo方法进行比较
 *		添加字符串,数字,日期的时候,会进行自动排序,是因为Integer,String,Date都实现了该接口和该方法
 *	如果我们要存储自定类型的时候,就需要让该类去实现对应的接口和方法才能进行存储
 * 
 * @author SEC90
 * @Date 2022年1月19日 下午3:54:06
 */
public class Collection_05_Set_02 {
	public static void main(String[] args) {
		TreeSet set = new TreeSet();
		User u1 = new User(15);
		User u2 = new User(17);
		User u3 = new User(20);
		User u4 = new User(18);
		User u5 = new User(4);
		set.add(u1);
		set.add(u2);
		set.add(u3);
		set.add(u4);
		set.add(u5);
		System.out.println(set);
	}
}
class User implements Comparable{
	@Override
	public int compareTo(Object o) {
		// this是要添加的元素
		// o是集合中的元素
		if (o instanceof User) {
			User u = (User) o;
			// 升序
			// return this.age - u.age;
			// 降序
			return u.age - this.age;
		}
		// 该方法 返回 0 说明重复,不添加
		// 返回 大于0的值 说明要添加的元素比集合中的大,就往后放
		// 返回 小于0的值 说明要添加的元素比集合中的元素小,就往前放
		return -1;
	}
	int age;

	@Override
	public String toString() {
		return " [" + age + "]";
	}

	public User(int age) {
		super();
		this.age = age;
	}
	
}

package _01_Collection;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * Comparator 也是比较器类 Comparable 也是做比较的 , 如果这两个同时存在,则Comparator优先级高
 * 
 * Comparable : 如果treeSet中保存我们自己定义的类型的时候,使用Comparable
 * 
 * Comparator : 如果treeSet中保存的不是我们写的类型的时候,就要使用Comparator来指定排序规则
 * 		比如 Integer 默认是升序排序,假如我们需要降序排序,我们只能使用 Comparator,因为我们不可能去更改Integer的源码
 * 		但此时 Integer中是有Comparable接口的实现的,等于两个比较都存在,但是Comparator优先级高,
 * 		所以会按照我们定义的规则进行排序
 * 		开闭原则 : 对修改关闭,对扩展开发
 * 
 * @author SEC90
 * @Date 2022年1月19日 下午4:04:00
 */
public class Collection_06_Comparator {
	public static void main(String[] args) {
		// 把比较器类的对象传入
//		TreeSet set = new TreeSet(new A());
		// 匿名内部类写法
		TreeSet set = new TreeSet(new Comparator () {
			@Override
			public int compare(Object o1, Object o2) {
				// o1 是要添加的元素
				// o2 是集合中的元素
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;
				// 该方法 返回 0 说明重复,不添加
				// 返回 大于0的值 说明要添加的元素比集合中的大,就往后放
				// 返回 小于0的值 说明要添加的元素比集合中的元素小,就往前放
				return i2-i1;
			}
		});
		set.add(1);
		set.add(2);
		set.add(3);
		set.add(4);
		System.out.println(set);
	}
}
// 比较器类
class A implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		// o1 是要添加的元素
		// o2 是集合中的元素
		Integer i1 = (Integer) o1;
		Integer i2 = (Integer) o2;
		// 该方法 返回 0 说明重复,不添加
		// 返回 大于0的值 说明要添加的元素比集合中的大,就往后放
		// 返回 小于0的值 说明要添加的元素比集合中的元素小,就往前放
		return i2-i1;
	}
	
}

package _01_Collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Collection_07_List {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(1);
		list.add(22);
		list.add(3);
		list.add(11);
		// 该方法会调用对象的Comparable中的compareTo方法或者是Comparator接口中的方法
		// 因为Integer中有compareTo方法,而且是升序,所以才可以使用sort方法
		// 比如想要降序可以使用sort方法重载
		// Collections.sort(list);
		Collections.sort(list, new Comparator() {

			@Override
			public int compare(Object o1, Object o2) {
				// o1 是要添加的元素
				// o2 是集合中的元素
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;
				// 该方法 返回 0 说明重复,不添加
				// 返回 大于0的值 说明要添加的元素比集合中的大,就往后放
				// 返回 小于0的值 说明要添加的元素比集合中的元素小,就往前放
				return i2 - i1;
			}
		});
		System.out.println(list);

		list = new ArrayList();
		list.add(new Student1(18));
		list.add(new Student1(11));
		list.add(new Student1(15));
		list.add(new Student1(4));
		// 因为Student1没有实现comparable接口 所以不能使用sort方法
		// Collections.sort(list);
		// 但是可以使用重载的方法
		Collections.sort(list,new Comparator () {
			@Override
			public int compare(Object o1, Object o2) {
				return 0;
			}
		});
	}
}

class Student1 {
	int age;

	public Student1(int age) {
		super();
		this.age = age;
	}

}

package _01_Collection;

import java.util.ArrayList;

public class Test {
	public static void main(String[] args) {
		m1(1);
		m2(new Test());
		ArrayList list = new ArrayList();
		list.add(1);
		list.add(11);
		list.add(12);
		list.add(13);
		list.add(14);
		list.add(15);
		list.remove(15);
		list.remove(new Integer(15));
	}

	public static void m1(double l) {

	}

	public static void m1(int l) {

	}
	public static void m2(Object o){
		
	}
	public static void m2(Test o){
		
	}
}