ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

JAVA基础-集合Collection

2020-07-03 20:39:56  阅读:199  来源: 互联网

标签:JAVA ArrayList System Collection println add 集合 out


首先总结一下集合的体系:

集合 的体系:
------------| Collection 单例集合的根接口
----------------| List 如果是实现了List接口的集合类,具备的特点: 有序,可重复。
-------------------| ArrayList 底层是维护了一个Object数组实现的。 特点: 查询速度快,增删慢。
-------------------| LinkedList 底层是使用了链表数据结构实现的, 特点: 查询速度慢,增删快。
-------------------| Vector(了解即可) 底层也是维护了一个Object的数组实现的,实现与ArrayList是一样的,但是Vector是线程安全的,操作效率低。

----------------| Set 如果是实现了Set接口的集合类,具备的特点: 无序,不可重复。
-------------------| HashSet 底层是使用了哈希表来支持的,特点: 存取速度快.
-------------------| TreeSet 如果元素具备自然顺序 的特性,那么就按照元素自然顺序的特性进行排序存储。

Collection

首先我们先来看一下JAVA中util包中几个集合之间的继承或实现关系:

1585366581107

可以看出Collection是所有集合的源头(实现接口)。

因为Colleciton是接口,所以我们不能直接实现他,只能利用子类向上转型来实现它。

Collection c = new ArrayList();

一些简单的API代码:


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo {
	
	public static void main(String[] args) {
		//集合 导包 全都是java.util包下的
		//无序 可重复
		//接口  向上转型特点  只能调用共有的属性和方法
		Collection c1 = new ArrayList();
		Collection c2 = new ArrayList();
		c2.add(10);
		c2.add(true);
		c2.add(33.4);
		c2.add("ddd");
		//1.添加    
		c1.add(10);
		c1.add(true);
		c1.add(33.4);
		c1.add("ddd");
		//添加集合
		c1.addAll(c2);
		System.out.println(c1);
		//2.清空全部元素
        //c1.clear();
		System.out.println(c1);
		c1.add(33.4);
		c1.add("ddd");
		//3.移除单个元素
		c1.remove("ddd");//移除里面的元素
		//c1.removeAll(c2);//移除里面的集合
		System.out.println(c1);
		//4.判断此集合是否是空元素集合
		System.out.println(c1.isEmpty());
		//5.判断此元素是否存在集合中  有返回true
		System.out.println(c1.contains(33.4));
		//c1.containsAll(c)判断集合是否存在此集合中
		//6.长度
		System.out.println("集合长度:"+c1.size());
		
		//遍历  只要集合中发现了迭代器方法  都可以使用foreach (for增强) 去遍历集合
		//1.foreach遍历 for(数组或集合数据类型   起个名字 :数组名或集合名){输出起的这个名}
		for(Object obj:c1) {
			System.out.println(obj);
		}
		System.out.println("---------------------------------------");
		//2.使用迭代器遍历集合
		//得到迭代器
		Iterator i1=c1.iterator();
		//判断游标后面有没有元素 有就返回true
		while(i1.hasNext()) {
			//返回游标下一个元素 并把游标位置移动到下一个位置
			System.out.println(i1.next());
		}
		//i1.hasNext()他返回的就是false
		System.out.println("i2------------------------------");
		//集合中有序无序 你要看他可不可以用下标访问元素
		Iterator i2=c1.iterator();
		while(i2.hasNext()) {
			//返回游标下一个元素 并把游标位置移动到下一个位置
			System.out.println(i2.next());
		}
		
	}
}

List

List和Collection相比,List是有序的集合,可以通过下标来索引。

其他的东西并不太特殊。

其中List的迭代器实现中,提供类listIterator()方法,下面总结了一下listIterator和Iterator两个迭代器不同的地方:

  1. 使用范围不同,Iterator可以应用于所有的集合,Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型。

  2. ListIterator有add方法,可以向List中添加对象,而Iterator不能。

  3. ListIterator和Iterator都有hasNext()和next()方法,可以实现顺序向后遍历,但是ListIterator有hasPrevious()和previous()方法,可以实现逆向(顺序向前)遍历。Iterator不可以。

  4. ListIterator可以定位当前索引的位置nextIndex()和previousIndex()可以实现。Iterator没有此功能。

  5. 都可实现删除操作,但是ListIterator可以实现对象的修改,set()方法可以实现。Iterator仅能遍历,不能修改。

下面是一些简单的API:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

public class ListDemo {

	public static void main(String[] args) {
		
		List l1=new ArrayList<>();
		//1.添加
		l1.add("ddd");
		l1.add(1);
		l1.add("gggg");
		l1.add(1);
		l1.add(1, "张三");
		System.out.println(l1);
		//2.移除
		System.out.println(l1.remove("gggg"));
		System.out.println(l1);
		//3.清空  长度 还有空集合判断  判断元素是否包含 跟collection一样的
		//4.通过下标得到元素
		System.out.println(l1.get(1));
		//5 替换
		l1.set(2, "李四");
		//6 indexof 返回此元素第一次出现的下标值 (索引值) 没有-1 lastindexof 返回最后一次出现的下标值
		System.out.println(l1.indexOf("李四"));
		//遍历  for循环  foreach  迭代器
		System.out.println("for循环--------------------");
		for (int i = 0; i <l1.size(); i++) {
			System.out.println(l1.get(i));
		}
		System.out.println("foreach---------------------");
		//foreach
		for(Object o1:l1) {
			System.out.println(o1);
		}
		System.out.println("迭代器--------------------");
		Iterator iterator = l1.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		System.out.println("列表迭代器-----------------");
		//列表迭代器 正序
		ListIterator listIterator = l1.listIterator();
		while(listIterator.hasNext()) {
			System.out.println(listIterator.next());
		}
		//倒序需要游标最后的时候使用打印才出内容
		System.out.println("列表迭代器2-----------------");
		ListIterator li2=l1.listIterator();
		while(li2.hasNext()) {
			System.out.println(li2.next());
		}
		System.out.println("倒序---------------------");
		while(li2.hasPrevious()) {
			System.out.println(li2.previous());
		}
	}
}

ArrayList和Vector

都是基于数组实现的 List 类,封装了一个动态的、允许再分配的 Object[] 数组,主要使用

initialCapacity 参数来设置该数组的长度,当添加的元素数量 过多的话,则 initialCapacity 会自动增

长,默认长度是 10。

有时候需要注意性能问题,如果向这两个集合中添加大量元素时,可用 ensureCapacity(int

minCapacity) 方法一次性地增加 initialCapacity,这样可以减少重分配的次数,提高新能。

它们也可以使用 ensureCapacity(int minCapacity) 和 trimToSize() 方法来重新分配 Object[] 数组。

Vector 是一个比较老旧的集合,是 ArrayList 的前身,有很多缺点,不建议使用。

ArrayList 是线程不安全的,如果多个线程访问&修改了 ArrayList 集合,就需要手动保证集合的同步

性。

Vector 是线程安全的,所以性能会比 ArrayList 稍低,哪怕是线程安全也不推荐使用。

public class ArrayListDemo2 {

	public static void main(String[] args) {
		ArrayList<String> aList=new ArrayList<String>();
		aList.add("ddd");
		aList.add("zhansgan");
		
		for (String string : aList) {
			System.out.println(string);
		}
		ArrayList aList2=new ArrayList<>();
		aList2.add("dd");
		aList2.add(2);
		
		for (Object object : aList2) {
			System.out.println(object);
		}
		//使用基本数据类型包装类 指定集合泛型
		ArrayList<Integer> aList3=new ArrayList<>();
		
		//迭代器
		Iterator<String>  i1=aList.iterator();
		while(i1.hasNext()) {
			System.out.println(i1.next());
		}	
		//泛型除了可以在集合中使用之外 也可以在类和方法中使用
	}
}

长度不变的集合(Arrays)

Arrays 类的 asList(Object... a) 静态方法,可以把一个数组或指定个数的对象转成一个 List 集合,这个集合

既不是 ArrayList 实现类的实例,也不是 Vector 实现类的实例,而是 Arrays 的内部类 ArrayList 的实

例。

Arrays.ArrayList 是一个固定长度的 List 集合,只能访问元素,不能添加和删除集合中的元素。

其源码如下:

    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

一些小demo代码:

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {

	public static void main(String[] args) {
		//...在方法中书写  调用方法时候可以书写多个参数 
		//注意...必须放置到最后一个参数类型后面
		//asList(T... a) 
		//返回的这个集合  长度不可变   不能添加不能删除
		List<String> l1=  Arrays.asList("张三","李四","王五");
		System.out.println(l1);
		l1.add("钱六");
		System.out.println(l1);
		
		
//		show(1,3,4);
	}
	
//	public static  void  show(Double b,int... a) {
//		
//	}
}

标签:JAVA,ArrayList,System,Collection,println,add,集合,out
来源: https://www.cnblogs.com/JeasonIsCoding/p/13232523.html

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

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

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

ICode9版权所有