ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

Day12 学习java（集合）

2022-01-19 21:02:50  阅读：170  来源： 互联网

标签：java list System println add Day12 集合 public out


集合

数组封装

需求

模拟一个数组，先预留空间，满了之后可以自动扩容,并且模拟出增删改查操作

编码实现

public class Array {
	private Object[] elements;
	// 数组中已有元素个数
	private int size = 0;

	// 默认容量为10
	public Array() {
		elements = new Object[10];
	}

	// 获取元素个数
	public int size() {
		return size;
	}

	// 长度
	public int length() {
		return elements.length;
	}

	// 根据索引获取
	public Object get(int index) {
		if (index >= size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
		return elements[index];
	}

	// 更改
	public void set(int index, Object element) {

		if (index >= size)
			throw new ArrayIndexOutOfBoundsException(index);
		elements[index] = element;
	}

	// 添加
	public void add(Object element) {
		// 先判断是不是满了
		if (size == elements.length) {
			Object[] newArr = new Object[size << 1];
			System.arraycopy(elements, 0, newArr, 0, elements.length);
			elements = newArr;
		}
		elements[size++] = element;
	}

	// 删除
	public void remove(int index) {
		if (index >= size)
			throw new ArrayIndexOutOfBoundsException(index);
		// 移位
		for (int i = index; i < size - 1; i++) {
			elements[i] = elements[i + 1];
		}
		// 最后一位赋值为null
		elements[size --] = null;
	}
}

测试

public class Test {

	public static void main(String[] args) {
		Array arr = new Array();
		arr.add(0);
		arr.add(1);
		arr.add(2);
		arr.add(3);
		arr.add(4);
		arr.add(5);
		arr.add(6);
		arr.add(7);
		arr.add(8);
		arr.add(9);
		arr.add(10);
		System.out.println(arr.get(5));
		arr.remove(5);
		for (int i = 0; i < arr.size(); i++) {
			System.out.print(arr.get(i) + "  ");
		}
		System.out.println();
		System.out.print(arr.length());
	}

}

在这里插入图片描述

集合

概述

Java集合是使程序能够存储和操纵元素不固定的一组数据。所有Java集合类都位于java.util包中。那么有一个问题是：之前我们需要把多个元素放到一起的时候，使用的是数组，那么为何还要提供Java集合工具类呢？
我们通过对比数组和Java集合工具类来解释Java集合工具类的必要性
在这里插入图片描述
如果集合中存放基本类型，一定要将其"装箱"成对应的"基本类型包装类"

继承体系

在这里插入图片描述
Collection是集合，两个直接子接口是List和Set
List 特性：有序，可重复，保证数据的添加顺序和取出顺序一致
Set 特性：无序，不可重复，不能保证数据的添加和取出顺序一致
List 有三个子类

  • ArrayList：底层是数组，查询和更改效率极高
  • LinkedList：底层是双向链表，添加和删除效率要高一些
  • Vector：底层也是数组，是 线程安全 ，已废弃，不推荐使用，被ArrayList代替
    Set 有两个子类
  • HashSet：底层是散列表
  • TreeSet：底层是二叉树

collection

Collection作为集合类的父类，所以，Collection中的方法是所有集合类都有的方法

常用方法

在这里插入图片描述

使用方式

以ArrayList为例

public class Collection_01 {

	public static void main(String[] args) {
		// 创建一个ArrayList对象
		Collection collection = new ArrayList();
		// 判断是否为空（有没有数据，而不是null）
		System.out.println(collection.isEmpty());
		// 已有元素个数
		System.out.println(collection.size());
		// 添加，如果添加一个基本类型，则会进行自动装箱为对应的包装类类型，然后再发生多态转型为Object类型
		collection.add(1);
		collection.add(2);
		collection.add(3);
		collection.add("张三");
		System.out.println(collection.isEmpty());
		System.out.println(collection.size());
		System.out.println(collection);
		// 根据数据删除指定元素（不是索引）
		collection.remove(3);
		System.out.println(collection);
		// 转换为数组
		Object[] arr = collection.toArray();
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		// 清空集合中的数据
		collection.clear();
		System.out.println(collection.size());
	}

}

在这里插入图片描述

iterator

  • Iterator 迭代器
    迭代器是一种模式，它可以使遍历和被遍历的对象相分离，我们就不再关心底层是什么数据结构，是如何进行数据存储的。只要拿到迭代器对象，就可以进行遍历

collection中，提供了一个iterator（）方法，用于获取迭代器对象

  •  	集合.iterator（）；

迭代器中，有三个方法

  •  	 boolean hasNext()：判断游标下是否还有元素，默认指向顶端，并没有指向第一个元素

  •  	 E next（）：将迭代器游标向下移动一位，并取出该元素

  •  	 remove（）：删除当前执行的元素，会把集合中的也删除

迭代器一旦创建，集合不能添加和删除，如果添加和删除了，需要重新生成迭代器

增强for循环forEach 就是迭代器的简写方式

public class Collection_02 {

	public static void main(String[] args) {
		// 创建
		Collection c = new ArrayList();
		// 添加
		c.add(10);
		c.add(11);
		c.add(12);
		c.add(13);
		c.add(14);
		// 生成迭代器
		Iterator it = c.iterator();
		// 生成迭代器之后，不能添加和删除，除非重新生成
		while (it.hasNext()) {
			Object o = it.next();
			System.out.println(o);
		}
		// 迭代器使用完之后，想要再次使用，需要重新生成，因为光标已经指向最后一个了
		it = c.iterator();
		while (it.hasNext()) {
			Object o = it.next();
			System.out.println(o);
		}
	}

}

在这里插入图片描述

注意

contains（Object o）：判断是否包含某个元素
remove（Object o）：删除指定元素
这两个方法，底层都会去调用equals方法进行比较

public class Collection_03 {

	public static void main(String[] args) {
		Collection c = new ArrayList();
		Integer i1 = new Integer(1234);
		Integer i2 = new Integer(1234);
		c.add(i1);
		// true
		System.out.println(c.contains(i1));
		// true 因为Integer 覆写了equals方法，比较的是值
		System.out.println(c.contains(i2));
		// 当我们保存的自定义类对象的时候，需要使用contains和remove的时候要注意覆写equals方法
		c = new ArrayList();
		A a1 = new A(1, "a");
		A a2 = new A(1, "a");
		c.add(a1);
		System.out.println(c.contains(a1));
		System.out.println(c.contains(a2));
		System.out.println(c);
	}

}

class A {
	int id;
	String name;

	public A() {
		super();
	}

	public A(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj instanceof A) {
			A a = (A) obj;
			if (this.id == a.id && this.name == a.name)
				return true;
		}
		return false;
	}

	public String toString() {
		return name + "    " + id;
	}
}

在这里插入图片描述

forEach

public class Collection_forEach {

	public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4 };
		// 会把数组中每个元素赋值给变量element 不是下标
		for (int element : a) {
			System.out.println(element);
		}

		Collection c = new ArrayList();
		c.add("a");
		c.add("b");
		c.add("c");
		// forEach是迭代器的简写方式，所以功能优先，只能查询，不能删除
		// 想要在遍历中删除，需要使用迭代器的remove
		for (Object o : c) {
			System.out.println(o);
		}
	}

}

在这里插入图片描述

List

ArrayList

public class Collection_05_List_01 {

	public static void main(String[] args) {
		List list = new ArrayList();
		// 集合中只能保存引用类型数据，如果添加的是基本类型的话
		// 会先进行自动装箱为对应的包装类，然后发生多态转型为Object类型
		// add（E e）：尾部添加
		list.add(1);
		list.add(2);
		// add(int index,E e) :把元素插入到指定位置，非特殊情况，尽量不用，以为其他元素需要向后移动位置
		list.add(0, 3);
		// set(int index,E e) :更改指定索引的元素值
		list.set(1, 4);
		// get(int index)获取对应索引的元素值
		System.out.println(list.get(0));
		// list中remove方法有重载
		// 如果传入的是int值，则是删除对应索引的元素，根据索引删除
		// 如果传入引用类型的值，则是删除对应的数据，根据元素删除
		// 删除索引为0的数据
		list.remove(0);
		// 删除值为4的元素
		//区别
		list.remove(Integer.valueOf(4));
		System.out.println(list);
	}

}

在这里插入图片描述
同时在Collections里面提供了sort方法对List升序排列

LinkedList

LinkedList ：底层是一个双向链表，因为不是连续存储，
只是能够找到下一个元素的地址而已，所以进行添加和删除操作效率比较高
但是查询效率较低，因为只能从第一个挨个找

public class Collection_01 {

	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		// ArrayList list = new ArratList();
		// 添加到尾部
		list.add(0);
		list.add(1);
		list.add(3);
		list.add(2);
		list.add(4);
		// 添加到指定位置
		list.add(0, 5);
		// 添加到头部
		list.addFirst(6);
		// 尾部添加
		list.addLast(7);
		// 个数
		System.out.println(list.size());
		System.out.println(list);
		// 是否为空
		System.out.println(list.isEmpty());
		// 根据下标删除
		list.remove(0);
		System.out.println(list);
		// 根据数据删除
		list.remove(new Integer(0));
		System.out.println(list);
		// 更改
		System.out.println(list.get(2));
		// 获取
		list.get(2);
		for (Object o : list) {
			System.out.print(o + "  ");
		}
		System.out.println();
		// 清空
		list.clear();
		System.out.println(list.isEmpty());

	}

}

在这里插入图片描述

对于ArrayList和LinkedList的测试

public class Collection_03 {

	public static void main(String[] args) {
		// 数据为例
		long starttime = System.currentTimeMillis();
		pushToArrayList();
		long endtime = System.currentTimeMillis();
		System.out.println("十万条数据从头插入ArrayList消耗的时间：  " + (endtime - starttime));

		starttime = System.currentTimeMillis();
		pushToLinkedList();
		endtime = System.currentTimeMillis();

		System.out.println("十万条数据从头插入LinkedList消耗的时间：  "
				+ (endtime - starttime));

		starttime = System.currentTimeMillis();
		addToArrayList();
		endtime = System.currentTimeMillis();
		System.out.println("百万条数据插入ArrayList消耗的时间：  " + (endtime - starttime));

		starttime = System.currentTimeMillis();
		addToLinkedList();
		endtime = System.currentTimeMillis();
		System.out.println("百万条数据插入LinkedList消耗的时间：  " + (endtime - starttime));

	}

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

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

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

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

在这里插入图片描述

标签：java,list,System,println,add,Day12,集合,public,out
来源： https://blog.csdn.net/Qiyesama1314/article/details/122569359

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有