JAVA核心编程之集合-EW帮帮网

1. java集合框架

Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中

Collection接口存储一组不唯一，无序的对象
List接口存储一组不唯一，有序（插入顺序）的对象
Set 接口存储一组唯一，无序的对象
Map接口存储一组键值对象，提供key到value的映射

2.List接口的实现类

2.1 ArrayList

实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高

方法名	说明
boolean add(Object o)	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)	在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size()	返回列表中的元素个数
Object get(int index)	返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
boolean remove(Object o)	从列表中删除元素
Object remove(int index)	从列表中删除指定位置元素，起始索引位置从0开始

注：**Collection****接口常用通用方法还有：clear()、isEmpty()、iterator()、toArray()

package cn.bdqn.demo01;

public class NewsTitle {

	private int id;
	private String name;
	private String author;

	public NewsTitle() {
		super();
	}

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

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	@Override
	public String toString() {
		return "NewsTitle [id=" + id + ", name=" + name + ", author=" + author
				+ "]";
	}

}

package cn.bdqn.demo01;

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

public class ArrayListDemo01 {

	public static void main(String[] args) {

		// 准备数据：创建5个NewsTitle类对象
		NewsTitle nt1 = new NewsTitle(1001, "三亚新增本土480+774", "百度");
		NewsTitle nt2 = new NewsTitle(1002, "中国成功发射一箭十六星", "中国航天");
		NewsTitle nt3 = new NewsTitle(1003, "男子救落水5人后遇难 同伴讲述经过", "民间观察");
		NewsTitle nt4 = new NewsTitle(1004, "苏氏祖祠：苏炳添是苏东坡第29代孙", "生活观察");
		NewsTitle nt5 = new NewsTitle(1005, "家长花200万给娃集奥特曼卡没集齐", "合肥观察");

		// 准备容器：创建集合对象，创建ArrayList对象
		ArrayList al = new ArrayList();

		// 将数据存储到集合中，向集合中添加元素不是通过元素下标来赋值，而是通过集合对象调用方法实现
		al.add(nt1);
		al.add(nt3);
		al.add(nt4);
		al.add(nt2);
		al.add(nt4);

		// 可以通过集合对象调用方法实现对集合中元素的操作
		// 获取集合中的元素个数
		int size = al.size();
		System.out.println("al集合中元素个数：" + size);

		// 获取集合中指定位置的元素
		// Object obj0=al.get(0);//返回值为Object类
		// NewsTitle nwt0 = (NewsTitle)obj0;//向下转型
		// System.out.println(nwt0);
		//
		// Object obj1=al.get(1);
		// NewsTitle nwt1 = (NewsTitle)obj1;
		// System.out.println(nwt1);
		//
		// Object obj2=al.get(2);
		// NewsTitle nwt2 = (NewsTitle)obj2;
		// System.out.println(nwt2);
		//
		// Object obj3=al.get(3);
		// NewsTitle nwt3 = (NewsTitle)obj3;
		// System.out.println(nwt3);
		//
		// Object obj4=al.get(4);
		// NewsTitle nwt4 = (NewsTitle)obj4;
		// System.out.println(nwt4);

		// 遍历集合
		for (int i = 0; i < al.size(); i++) {
			Object object = al.get(i);//获取第i个元素的值
			NewsTitle ntw = (NewsTitle) object;//向下转型
			System.out.println(ntw);
		}

		System.out.println("--------------------");

		// 增强for循环遍历集合
		for (Object object : al) {
			NewsTitle ntw = (NewsTitle) object;
			System.out.println(ntw);
		}

		System.out.println("--------------------");

		// 使用迭代器遍历集合
		/*
		 * 集合对象调用iterator()方法将集合中的所有元素按照顺序取出来放入到迭代器容器里面
		 * 然后通过迭代器对象调用hasNext()方法判断迭代器中是否有元素，有元素就通过next()方法取出这个元素
		 * 判断一个就取出一个，判断一个就取出一个，所以可以使用循环来取出里面所有的元素
		 */

		Iterator it = al.iterator();//将所有元素取出来放在迭代器容器中
		while (it.hasNext()) {//
			Object object = it.next();
			NewsTitle nt = (NewsTitle) object;
			System.out.println(nt);
		}

		System.out.println("--------------------");

		//将数据存储到集合中的指定位置
		al.add(1, nt5);
		// 增强for循环遍历集合
		for (Object object : al) {
			NewsTitle ntw = (NewsTitle) object;
			System.out.println(ntw);
		}
		
		System.out.println("---------------------");
		
		//删除集合中的某个元素
		Object ob=al.remove(1);
		al.remove(nt3);
		for (Object object : al) {
			NewsTitle ntw = (NewsTitle) object;
			System.out.println(ntw);
		}
		
		//判断集合中是否包含指定的元素
		boolean result =al.contains(nt1);
		System.out.println("集合中包含nt3元素："+result);
		
		//判断几个是不是空的
		System.out.println("集合是空的："+al.isEmpty());
		
		System.out.println("****************************");
		//将集合转换成数组
		Object[] objects=al.toArray();
		for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);
		}
		
		System.out.println("****************************");
		//清空集合
		al.clear();
		System.out.println("集合是空的："+al.isEmpty());
		System.out.println(al.size());
		
	}

}

2.2 LinkedList

采用链表存储方式，插入、删除元素时效率比较高

方法名	说明
void addFirst(Object o)	在列表的首部添加元素
void addLast(Object o)	在列表的末尾添加元素
Object getFirst()	返回列表中的第一个元素
Object getLast()	返回列表中的最后一个元素
Object removeFirst()	删除并返回列表中的第一个元素
Object removeLast()	删除并返回列表中的最后一个元素

package cn.bdqn.demo01;

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

public class LinkedListDemo01 {

	public static void main(String[] args) {
		// 准备数据：创建5个NewsTitle类对象
		NewsTitle nt1 = new NewsTitle(1001, "三亚新增本土480+774", "百度");
		NewsTitle nt2 = new NewsTitle(1002, "中国成功发射一箭十六星", "中国航天");
		NewsTitle nt3 = new NewsTitle(1003, "男子救落水5人后遇难 同伴讲述经过", "民间观察");
		NewsTitle nt4 = new NewsTitle(1004, "苏氏祖祠：苏炳添是苏东坡第29代孙", "生活观察");
		NewsTitle nt5 = new NewsTitle(1005, "家长花200万给娃集奥特曼卡没集齐", "合肥观察");

		// 准备容器：创建集合对象，创建LinkedList对象
		// List是一个接口，LinkedList是List接口的实现类，将List接口引用指向了实现类的实例，
//		向上转型：父类（接口）的引用指向子类的实例，父类引用无法调用子类特有的方法
		List list = new LinkedList();
		list.add(nt1);
		list.add(nt3);
		list.add(nt2);
		list.add(nt2);
		
		System.out.println(list.size());
		
		//使用迭代器将list集合进行遍历
		Iterator it =list.iterator();
		while(it.hasNext()){
			Object object =it.next();
			NewsTitle nt = (NewsTitle)object;
			System.out.println(nt);
		}
		
		System.out.println("-------------------------");
		
		//向下转型：子类的引用指向父类的对象  需要进行向下转型的原因是父类引用无法调用子类中特有的方法，子类特有的方法只能通过子类对象调用
		LinkedList link = (LinkedList)list;
		link.addFirst(nt5);
		link.addLast(nt4);
		for (Object object : link) {
			System.out.println(object);
		}
		
		System.out.println("-------------------------");
		
		//获取集合中的第一个元素和最后一个元素
		System.out.println(link.getFirst());
		System.out.println(link.getLast());
		
		System.out.println("-------------------------");
		//删除集合中的第一个元素和最后一个元素
		link.removeFirst();
		link.removeLast();
		for (Object object : link) {
			System.out.println(object);
		}	
	}

}

3 Set接口的实现类

- Set接口存储一组唯一，无序的对象

- HashSet是Set接口常用的实现类（Set接口不存在get()方法）

- Set中存放对象的引用

public class HashSetDemo01 {

	public static void main(String[] args) {
		
		//准备容器：创建HashSet对象
		Set set=new HashSet();
		
		//准备数据
		String s1=new String("java");
		String s2=s1;
		String s3=new String("JAVA");
		
		//将元素添加到集合中
		set.add(s1);
		set.add(s2);
		set.add(s3);
		
		//获取集合中的元素个数
		System.out.println(set.size());//2
	}
}

Set接口不存在get()方法

通过迭代器Iterator实现遍历的步骤

获取Iterator ：Collection 接口的iterator()方法
nIterator的方法

boolean hasNext(): 判断是否存在另一个可访问的元素

Object next(): 返回要访问的下一个元素

package cn.bdqn.demo02;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo03 {

	public static void main(String[] args) {
		// 准备容器
		HashSet hs = new HashSet();

		// 准备数据：创建5个NewsTitle类对象
		NewsTitle nt1 = new NewsTitle(1001, "三亚新增本土480+774", "百度");
		NewsTitle nt2 = new NewsTitle(1002, "中国成功发射一箭十六星", "中国航天");
		NewsTitle nt3 = new NewsTitle(1003, "男子救落水5人后遇难 同伴讲述经过", "民间观察");
		NewsTitle nt4 = new NewsTitle(1004, "苏氏祖祠：苏炳添是苏东坡第29代孙", "生活观察");
		NewsTitle nt5 = new NewsTitle(1005, "家长花200万给娃集奥特曼卡没集齐", "合肥观察");

		// 将数据存储到集合中
		hs.add(nt1);
		hs.add(nt3);
		hs.add(nt5);
		hs.add(nt2);
		hs.add(nt4);
		hs.add(nt4);

		// 获取集合中元素个数
		System.out.println(hs.size());//5 set集合中的元素具有唯一性

		// 获取集合中的元素
		for (Object object : hs) {
			NewsTitle nt = (NewsTitle) object;//向下转型
			System.out.println(nt);
		}

		System.out.println("--------------");

		Iterator it = hs.iterator();
		while (it.hasNext()) {
			Object object = it.next();
			NewsTitle nt = (NewsTitle) object;
			System.out.println(nt);
		}
	}
}

4 Map接口

Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作

最常用的实现类是HashMap

方法名	说明
Object put(Object key, Object val)	以“键-值”对的方式进行存储
Object get(Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove(Object key)	删除由指定的键映射的“键-值对”
int size()	返回元素个数
Set keySet()	返回键的集合
Collection values()	返回值的集合
boolean containsKey(Object key)	如果存在由指定的键映射的“键-值对”，返回true

package cn.bdqn.demo02;

import java.util.*;

public class HashMapdemo01 {
    public static void main(String[] args) {
        //准备容器，创建HashMap对象
        HashMap hashMap = new HashMap();
        //准备元素并将元素存储到集合中
        hashMap.put("CN","中华人民共和国");
        hashMap.put("RU","俄罗斯联邦");
        hashMap.put("JP","日本国");
        hashMap.put("USA","美利坚合众国");
        hashMap.put("UK","大不列颠及北爱尔兰联合王国");

        //获取元素个数
        System.out.println(hashMap.size());
        //根据键获取对应的值
        Object obj=hashMap.get("CN");
        String str1=(String)obj;//向下转型为String类
        System.out.println(str1);
        //也可以这样
        System.out.println(hashMap.get("CN"));
        //根据键删除对应的值
        Object obj2= hashMap.remove("JP");
        String str2=(String)obj2;
        System.out.println(str2);
        System.out.println(hashMap.size());
        //获取HashMap集合中所有键值对应的键
        Set keys=hashMap.keySet();//KeySet返回值类型为Set类
        //增强for
        for (Object o :keys) {
            //            System.out.println(o);//
            String str3=(String)o;
            System.out.println(str3);
        }
        //获取HashMap集合中所有键对应的值的集合
        Collection values = hashMap.values();//values返回的值为Collection类
        for (Object o :values) {
            String str4=(String)o;
            System.out.println(str4);
        }
        //查询集合中是否存在指定键对应的键值对
        System.out.println(hashMap.containsKey("RU"));//true
        System.out.println("================");
        //遍历建的三种方法
        //方式一、获取键的集合，然后遍历键的集合过程中调用get()方法获取
        Set keys1=hashMap.keySet();//获取建的集合
        for (Object o :keys1) {
            //获取键
            String str=(String)o;
            //根据键获取值
            Object obj1=hashMap.get(str);//根据一个建获取一个值
            System.out.println(str+"=="+obj1);
        }
        System.out.println("================");
        //方式二，迭代器遍历
        Set keys2=hashMap.keySet();
        Iterator iterator = keys2.iterator();
        while (iterator.hasNext()) {
            //获取键
            Object obj3 =  iterator.next();
            //根据键获取值
            Object obj4=hashMap.get(obj3);
            System.out.println(obj3+"=="+obj4);

        }
        System.out.println("=================");
        //方式三：键值对遍历，将hashMap集合中的键值对整体取出来后放入Set中
        /*
         * 使用entrySet()方法将hashMap集合中的键值对整体取出放在Set集合中
         * 然后使用增强for或者迭代器取出Set集合中的键值对元素，，取出来的是Object类型，实际上键值对的真正类型是Map.Entry类型
         * 所以将取出来的元素强制转换为Map.Entery类型。Map.Entry类中的getKey（）方法获取键值对的键，get.Valua()方法获取键值对的值
         */
       
        Set set = hashMap.entrySet();
        for (Object o :set) {
            System.out.println(o);
           //或者
            Map.Entry me=(Map.Entry)o;
            Object object = me.getKey();
            String key=(String)object;
            Object value = me.getValue();
            String key2=(String)value;
            System.out.println(key+"=="+key2);

        }
    }
}

本文含有隐藏内容，请开通VIP 后查看

JAVA核心编程之集合

1. java集合框架

2.List接口的实现类

2.1 ArrayList

2.2 LinkedList

3 Set接口的实现类

网站公告

今日签到

热门文章

最新发布