JAVA编程学习记录（集合2）

最新推荐文章于 2022-05-03 08:00:00 发布

学编程的鹿

最新推荐文章于 2022-05-03 08:00:00 发布

阅读量186

点赞数

本文链接：https://blog.csdn.net/otmqixi/article/details/80257428

版权

第七周集合1

摘要--Java集合类:

1.与数组类似，Java提供集合类的主要目的在于“保存多个数据/对象"，提供一种比数组下标存取方式更灵活的方法。

2.集合类存在于java.util包中，主要分为3中：Set、Lest和Map。Set表示不允许容纳重复元素的集合，List表示可以容纳重复元素的集合，Map表示存储键/值对的集合，每个键/值对称为一项。

集合接口：集合框架定义的几个接口，决定了集合框架各类的基本特性。不同的是，具体类仅仅是提供了标准接口的不同实现。

支持集合的主要接口有：

Collection接口：集合框架的顶层接口，定义了操作对象集合的共同方法。

List接口：继承Collection，表示有序的，可以包括重复元素的列表。

Set接口：继承Collection，表示无序的，无重复元素的集合（数学上的含义）。

SortedSet接口：继承Set，对Set中的元素进行排序。

面试题:

集合和数组的区别?

1.长度区别:a.数组长度固定.b.集合长度可变;

2.内容区别:a.数组可以存储同一种类型的元素.b.集合可以存储多种类型的元素

3.存储类型的区别:a.数组:可以存储基本类型,也可以存储引用类型.b.集合:只能存储引用类型

一 List集合

1、ArrayList

ArrayList是List接口中常用的一个子实现类

1.给ArrayList集合中添加字符串元素并遍历

package ArrayList;

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

public class ArrayListDemo {
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		
		list.add("hello");
		list.add("Java");
		
		// 遍历
		// 1.Collection的iterator()方法
		// 获取迭代器
		Iterator it = list.iterator();
		while(it.hasNext()) {
			String s = (String)it.next();
			System.out.println(s);
		}
		
		// 2.size()和get(int index)普通for循环
		for (int i = 0; i < list.size(); i++) {
			String s = (String)list.get(i);
			System.out.println(s);
		}
		
	}
}

2.ArrayList集合存储自定义对象并遍历

package ArrayList;

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

public class ArrayListDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList array = new ArrayList();
		// 创建Person类对象
		Person p1 = new Person("李明",15);
		Person p2 = new Person("李华",14);
		Person p3 = new Person("韩梅梅",16);
		Person p4 = new Person("李雷",13);
		
		// 给集合添加
		array.add(p1);
		array.add(p2);
		array.add(p3);
		array.add(p4);
		
		// 迭代器遍历
		Iterator it = array.iterator();
		while(it.hasNext()) {
			Person p = (Person)it.next();
			System.out.println(p.getName()+"---"+p.getAge());
		}
		System.out.println("---------华丽的分割线---------");
		// size()和get(int index)遍历
		for (int i = 0; i < array.size(); i++) {
			Person p = (Person)array.get(i);
			System.out.println(p.getName()+"---"+p.getAge());
		}
	}
}
// Person类
package ArrayList;

public class Person {
	private String name;
	private int age;
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

2、Vector集合

Vector非常类似ArrayList,但Vector底层是一种增长对象数组,查询快,增删慢,线程安全,同步,执行效率高。

特有功能：

public void addElement(Object obj)将指定的组件添加到此向量的末尾，将其大小增加 1。如果向量的大小比容量大，则增大其容量。

public Enumeration elements()：返回此向量的枚举--->相当于:public Iterator iterator()

boolean hasMoreElements()：--->相当于boolean hasNext() ;

package Vector;

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {
	public static void main(String[] args) {
		// 创建集合对象
		Vector v = new Vector();
		
		// 添加元素
		v.addElement("hello");
		v.addElement("world");
		v.addElement("java");
		
		// 遍历
		// 获取Enumeration:向量的枚举
		Enumeration en = v.elements();
		while(en.hasMoreElements()) {
			String s = (String) en.nextElement();
			System.out.println(s);
		}
	}
}

3、 LinkedList集合

LinkedList集合的特点：底层是一种链表实现，查询慢，增删快，线程不安全、不同步、执行效率高。

特有功能：

添加功能：

addFirst(Object e):将指定的元素插入到列表的开头

addLast(object e):将指定的元素添加到列表末尾

获取功能：

getFirst():获取列表第一个元素

getLast():获取列表第二个元素

删除功能：

public Object removeFirst()移除并返回此列表的第一个元素。

public Object removeLast()移除并返回此列表的最后一个元素。

package LinkedList;

import java.util.LinkedList;

public class LinkedListDemo {
	public static void main(String[] args) {
		// 创建LinkedList集合对象
		LinkedList link = new LinkedList();

		// 添加元素
		link.add("hello");
		link.add("world");
		link.add("java");
		System.out.println("link:" + link);// link:[hello, world, java]

		// 添加在开头
		link.addFirst("Hello");
		// 添加在末尾
		link.addLast("World");

		System.out.println("link:" + link);// link:[Hello, hello, world, java, World]

		// 获取第一个
		System.out.println(link.getFirst());// Hello
		// 获取最后一个
		System.out.println(link.getLast());// World

		// 移除并返回第一个元素
		System.out.println(link.removeFirst());// Hello
		System.out.println("link:" + link);// link:[hello, world, java, World]
		// 移除并返回最后一个元素
		System.out.println(link.removeLast());// World
		System.out.println("link:" + link);// link:[hello, world, java]
	}
}

LinkedList集合模拟栈结构--->先进后出

package LinkedList;

import java.util.LinkedList;

public class LinkedListDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		LinkedList link = new LinkedList();
		
		link.addFirst("hello");
		link.addFirst("world");
		link.addFirst("java");
		
		System.out.println(link);// [java, world, hello]
	}
}

创建一个专有的类完成这个操作

package LinkedList;

public class MyStackDemo {
	public static void main(String[] args) {

		// 创建MyStack类对象
		MyStack my = new MyStack();// LinkedList list = new LinkedList();
		// 添加元素
		// LinkedList ["hello","world","java"]
		my.add("hello");
		my.add("world");
		my.add("java");

		// 调用判断功能进行输出
		while (!my.isEmpty()) {
			System.out.println(my.get());
		}
		// java
		// world
		// hello

	}
}
package LinkedList;

import java.util.LinkedList;

public class MyStack {
	private LinkedList link;

	// 无参构造,实际是构造了个LinkedList对象
	public MyStack() {
		link = new LinkedList();
	}

	// 添加元素功能
	public void add(Object obj) {
		link.addFirst(obj);
	}

	// 获取元素
	public Object get() {
		return link.removeFirst();
	}

	// 判断功能(非空判断)
	public boolean isEmpty() {
		return link.isEmpty();
	}
}

ArrayList集合案例练习

（1）需求:给集合中添加重复的元素(字符串类型),将重复的元素从集合去除掉!

方法①

package ArrayList;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;

/**
 * 需求:给集合中添加重复的元素(字符串类型),将重复的元素从集合去除掉!
 *
 * 思路:
 * 		1)创建一个旧集合,添加重复元素
 *  	        2)创建一个新集合
 * 		3)遍历旧集合中的元素获取到每一个元素
 * 			在旧集合中判断新集合中是否包含旧集合中的元素
 * 				包含,不搭理
 * 				不包含,添加到新集合中
 * 		4)遍历新集合
 */
public class ArrayListTest {
	public static void main(String[] args) {
		
		// 创建一个集合
		ArrayList list = new ArrayList();
		
		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add("hello");
		list.add("world");
		
		// 创建一个新集合
		ArrayList newList = new ArrayList();
		
		// 遍历旧集合
		Iterator it = list.iterator();
		while(it.hasNext()) {
			String s = (String) it.next();
			// 
			if(!newList.contains(s)) {
				newList.add(s);			
			}
		}
		// 遍历新集合
		Iterator it2 = newList.iterator();
		while(it2.hasNext()) {
			String s = (String) it2.next();
			System.out.println(s);
		}
	}
}

方法②

package ArrayList;

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

/**
 * 需求:给集合中添加重复的元素(字符串类型),将重复的元素从集合去除掉! 方法2: 思路: 引入选择排序,用0索引对应的元素和后面的的索引依次比较,
 * 如果相同了则删除后面的元素.
 */
public class ArrayListTest2 {

	public static void main(String[] args) {

		// 创建集合对象
		ArrayList list = new ArrayList();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add("hello");
		list.add("world");

		// 利用size和get()遍历比较索引
		for (int i = 0; i < list.size() - 1; i++) {
			// j等于i索引加一,即j表示i后面的索引
			for (int j = i + 1; j < list.size(); j++) {
				// 比较i和j位置代表的元素,如果相同则移除j代表的那个索引
				if (list.get(i).equals(list.get(j))) {
					list.remove(j);
					// 代码优化:这时集合长度减一,减少比较次数
					j--;
				}
			}
		}
		// 遍历比较后的集合
		Iterator it = list.iterator();
		while (it.hasNext()) {
			String s = (String) it.next();
			System.out.println(s);
		}
	}
}

（2）需求:使用集合ArrayList存储自定义对象(Student),去除重复的对象(成员变量的值一样,看成一个人)

按照存储字符串(新建集合的思想)的形式来去存储自定义对象,发现自定义对象并没有去重,为什么?

因为contains方法底层依赖于equals方法，equals方法默认比较的是地址值,如果想让equals()方法比较他们的内容是否相同,需要重写equals(),也就意味着存储自定义类,必须重写。equals()方法,这样才能比较的是这些对象的内容是否相同

package ArrayList;

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

public class ArrayListTest3 {
	public static void main(String[] args) {
		
		// 创建ArrayList集合对象
		ArrayList list = new ArrayList();
		
		// 创建几个学生对象,包含重复元素
		Student s1 = new Student("李华",22);
		Student s2 = new Student("李明",24);
		Student s3 = new Student("韩梅梅",21);
		Student s4 = new Student("李华",23);
		Student s5 = new Student("李华",22);
		
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		list.add(s5);
		
		// 创建一个新集合
		ArrayList newlist = new ArrayList();
		
		// 遍历旧集合
		Iterator it = list.iterator();
		while(it.hasNext()) {
			Student s = (Student)it.next();
			// 判断,新集合中是否包含
			if(!newlist.contains(s)) {
				newlist.add(s);
			}
		}
		Iterator it2 = newlist.iterator();
		while(it2.hasNext()) {
			Student s = (Student)it2.next();
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}

Student类

package ArrayList;

public class Student {
	private String name;
	private int age;
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	} 
	// 重写equals方法
	@Override
	public boolean equals(Object obj) {
		if(this == obj)
			return true;
		if(obj == null)
			return false;
		if(getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}