06-单列集合

原创已于 2022-04-01 16:45:04 修改 · 101 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#eclipse

于 2022-03-28 09:24:41 首次发布

Java基础（简述）专栏收录该内容

15 篇文章

订阅专栏

提供批量数据的存储和处理方案

可以保存不同类型的数据，长度自增

常用方法

方法	作用	返回值
size()	元素个数	int
add(元素)	添加元素	boolean
addAll(集合)	添加集合进集合	boolean
isEmpty()	是否有元素	boolean
contains(元素)	是否包含元素	boolean
remove(元素)	移除元素	boolean
removeAll(集合)	移除集合	boolean
removeIf(Predicate filter)	移除有条件元素	boolean
clear()	清空集合	void
toArray()	集合转数组	Object[]
iterator()	获取集合迭代器对象	Iterator
Collections.copy(有固定长度的新集合, 老集合)	复制集合	ArrayList<>
Collections.sort(集合)	比较器	void
Collections.sort(集合，外部比较器实现类对象)	比较器	void

collections.copy

//必须创建固定长度的数组 将其转为有序集合实现类形式
ArrayList<String> al = new ArrayList<String>(Arrays.asList(new String[as.size()]));
//通过copy方法 将第二个参数（老集合）元素复制到第一个参数（新集合）中
Collections.copy(al, as);

removeIf(Predicate filter)用法

public class 类名 implements Predicate {
	@Override
	public boolean test(Object t) {
		// t表示每个元素通过逻辑判断,返回true移除,否则保留
        if(t instanceof Integer){
            return true;
        }
		return false;
	}
}
//测试类
//通过Predicate实现类对元素进行过滤
c.removeIf(new 类名());

迭代器

父类

Iterator

方法	作用	返回值
hasNext()	查询是否有下一个元素	boolean
next()	获取下一个元素,且指针下跳	Object

Iterator<User> it = 集合.iterator();
//查找下一个元素是否存在
while(lt.hasNext()) {
    //获取下一个元素 并且指针下跳
    System.out.println(lt.next());
}

子类

ListIterator（双向迭代器）

方法	作用	返回值
hasNext()	查询是否有下一个元素	boolean
next()	获取下一个元素,且指针下跳	Object
hasPrevious()	查询是否有上一个元素	boolean
previous()	获取上一个元素，且指针上跳	Object

ListIterator<User> li = 集合.listIterator(集合.size());
//查找上一个元素是否存在
while(li.hasPrevious()) {
    //获取上一个元素 并且指针上跳
    System.out.println(li.previous());
}

比较器

内部比较器

实现Comparable<E>接口内的compareTo(E e)方法

// 先在实体类中（保存的类型）实现Comparable接口
public class User implements Comparable<User>{
    String name;
    int age;
    @Override
    public int compareTo(User o) {
        //2.编写比较规则
        if(this.name.equals(o.name)) {
            //当姓名相同的时候
            //降序
            return o.age - this.age;
            //升序
            //return this.age - o.age;
        }
        //姓名不同的时候，this在前 升序
        return this.name.compareTo(o.name);
    }
}
// 3.测试类
// 写好User类型的排序规则，使用Collections.sort()会通过冒泡排序 调用比较规则
Collections.sort(集合);

外部比较器

有多种排序方案，单独创建排序类

实现Comparator<E>接口类的compare(E o1,E o2)方法

//单独创建一个类，实现Comparator接口作为外部比较器类
public class 外部比较器 implements Comparator<User> {
    @Override
    public int compare(User o1, User o2) {
        // 姓名降序 年龄降序 成绩降序
        if(o1.name.equals(o2.name)) {
            if(o1.age == o2.age) {
                return o2.score > o1.score?1:-1;//降序
            }
            return o2.age - o1.age;
        }
        return o2.name.compareTo(o1.name);
    }
}
//测试类
Collections.sort(集合, new 外部比较器());

去重

java通过重写hashCode()和equals(Object)实现去重

泛型

约束可保存数据的类型，否则默认为Object类型

List（有序集合）

保存顺序与输出顺序一致
有索引，可保存重复数据
可使用任意循环输出展示

ArrayList

底层为数组模型
增删慢，扩容移动元素
查询快，通过下标锁定元素

构造方法

构造方法	作用
new ArrayList()	空参构造 - 默认长度为10的数组
new ArrayList(int)	单参构造 - 参数定义初始数组长度
new ArrayList(集合)	可将其他单列集合传入，转为有序集合

常用方法

方法	作用	返回值
add(下标,元素)	指定下标加元素	void
get(下标)	下标找元素	E
indexOf(元素)	元素找下标	int
lastIndexOf(元素)	元素逆向找下标	int
remove(下标)	下标删对象，返回移除元素	Object
set(下标,元素 )	新元素换下标老元素,返回老元素	E
listIterator()	获取双向迭代器	ListIterator<E>
listIterator(下标)	获取双向迭代器,设置指针初始位置	ListIterator<E>

LinkedList

双链结构
增删快，无需移动和扩容，也不会产生垃圾数据
查询慢，查询需从头或尾部查找

构造方法

构造方法	作用
new LinkedList()	空参构造 - 默认长度为10的数组
new LinkedList(集合)	可将其他单列集合传入，转为有序集合

常用方法

方法	作用	返回值
addFirst(E)	头部添加元素	void
addLast(E)	尾部添加元素	void
getFirst()	获取第一个元素	E
getLast()	获取最后一个元素	E
removeFirst()	删除第一个元素	E
removeLast()	删除最后一个元素	E

Vector

线程安全的古老集合

Vector<Integer> vi = new Vector<Integer>();
//Vector特有迭代器
Enumeration<Integer> en = vi.elements();
while(en.hasMoreElements()) {
    System.out.println(en.nextElement());
}