Java周记（第三周）容器

码码忽忽

已于 2022-05-22 09:39:03 修改

阅读量165

点赞数 1

文章标签： java 开发语言

于 2022-05-22 09:30:01 首次发布

本文链接：https://blog.csdn.net/qq_62243433/article/details/124842990

版权

第九章容器

1.容器

数组就是一种容器，可以在其中放置对象或基本类型数据。

数组的优势：是一种简单的线性序列，可以快速地访问数组元素，效率高。如果从效率和类型检查的角度讲，数组是最好的。

数组的劣势：不灵活。容量需要事先定义好，不能随着需求的变化而扩容。比如：我们在一个用户管理系统中，要把今天注册的所有用户取出来，那么这样的用户有多少个?我们在写程序时是无法确定的。因此，在这里就不能使用数组。

基于数组并不能满足我们对于“管理和组织数据的需求”，所以我们需要一种更强大、更灵活、容量随时可扩的容器来装载我们的对象。这就是容器，也叫集合。

2.泛型

泛型的本质是“数据类型的参数化”。就是将原来的具体的类型参数化，然后调用此方法时传递形参，我们可以把“泛型”理解为数据类型的一个占位符（形式参数），即告诉编译器，在调用泛型时必须传入实际类型。

泛型<T,E,V>像一个占位符一样表示“未知的某个数据类型”，我们在真正调用的时候传入这个“数据类型”

泛型定义格式：

1.<类型>：指定一种类型的格式，这里的类型可以看成是形参

2.<类型1，类型2，......>：指定多种类型的格式，多种类型之间用逗号隔开，这里的类型可看作形参

3.将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

package rongqi;

public class testgeneric {
	public static void main(String[]args) {
		mycollection<String> mc=new mycollection<String>();
		
		mc.set("张三", 0);
		String b=mc.get(0);
	}
}

class mycollection<E>{
	Object[] objs=new Object[5];
	public void set(E e,int index) {
		objs[index]=e;
		
	}
	public E get(int index) {
		return (E)objs[index];
	}
}

3.Collection接口

Collection表示一组对象、同时集中，收集的意思，Collection接口的两个子接口是List、Set接口。

JDK不实现此接口的任何直接实现，他提供更具体的子接口实现

创建Colection集合的对象的方式：

1.多态的方式

2.具体的实现类ArrayList

import java.util.*;

public class testlist {
	public static void main(String[]args) {
		Collection<String> c=new ArrayList<String>();
		
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		System.out.println(c);//[hello, world, java]
	}
}

Collection集合常用的方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

import java.util.*;

public class testlist {
	public static void main(String[]args) {
		Collection<String> c=new ArrayList<String>();
		
		//添加元素
		System.out.println(c.add("hello"));//true
		System.out.println(c.add("world"));//true
		System.out.println(c.add("world"));//true
		c.add("java");
		System.out.println(c.remove("world"));
		System.out.println(c.contains("javaee"));//判断集合中是否存在指定的元素
		
		System.out.println(c.isEmpty());//判断集合是否为空
		System.out.println(c.size());//集合的长度，集合中元素的个数
        c.clear();//清空集合中的元素
		System.out.println(c);
		
	}
}

Collection集合的遍历

Iterator：迭代器，集合的专用遍历方式

Iterator<E>iterator()：

1.返回集合中元素的迭代器，通过集合的iterator（）方法得到

2.迭代器是通过集合的iterator（）方法得到的，所以我们说他是依赖于集合而存在的

Iterator中的常用方法：

1.E next()：返回迭代中的下一个元素

2.boolean hasNext（）：如果迭代具有更多元素，则返回true

import java.util.*;

public class testdome {
	public static void main(String[]args) {
		//创建集合对象
		Collection<String> c=new ArrayList<String>();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		Iterator<String> it=c.iterator();
		
//		System.out.println(it.next());//hello
//		System.out.println(it.next());//world
//		System.out.println(it.next());//java
		//System.out.println(it.next());//NoSuchElementException,被请求的元素不存在
		while(it.hasNext()) {
			//System.out.println(it.next());
			String s=it.next();
			System.out.println(s);
		}
	}
}

操作多个List

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

public class testlist {
    public static void main(String[]args){
        test01();
    }
    public static void test01(){
        Collection<String> c=new ArrayList<>();
        c.add("aa");
        c.add("bb");
        c.add("cc");
        Collection<String> c1=new ArrayList<>();
        c1.add("aa");
        c1.add("dd");
        c1.add("ee");
        c.retainAll(c1);//取交集
        System.out.println(c);//[aa]
        c.addAll(c1);//添加
        System.out.println(c);//[aa, aa, dd, ee]
        c.removeAll(c1);//从c中移除于c1相同的
        System.out.println(c);
    }

}

List是有序、可重复的容器

有序：List中每个元素都有索引标记，可以根据元素的索引标记（在List中的位置）访问元素，从而精确的控制这些元素。

可重复：List允许加入重复的元素，更确切地讲，List通过允许满足e1.equals(e2)的元素重复加入容器。

常用的实现类：ArrayList、LinkedList、Vector

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class testlist {
    public static void main(String[]args){
        test02();
    }
    public static void test02(){
        List<String> a=new ArrayList<>();
        a.add("A");
        a.add("B");
        a.add("C");
        a.add("D");
        a.add(2,"你好");//[A, B, 你好, C, D]
        System.out.println(a);
        a.remove(2);//[A, B, C, D]
        System.out.println(a);
        a.set(2,"你好");//[A, B, 你好, D],直接覆盖原来的
        System.out.println(a);
        System.out.println(a.get(2));//你好,获取第二个索引位置
        System.out.println(a.indexOf("BZ"));//返回不存在的，输出-1
        System.out.println(a.indexOf("B"));//返回第一个B所在的索引位置
        System.out.println(a.lastIndexOf("你好"));//返回最后出现的该字符的索引位置
    }
}

4.Map接口

存储时使用键值对，键不能重复（如果重复，新的健将覆盖旧的键）

Map接口的实现类有HashMap、TreeTable、Properties

Map的方法

import java.util.HashMap;
import java.util.Map;

public class testmap {
    public static void main(String[]args){
        Map<Integer,String> m1=new HashMap<>();
        m1.put(1,"one");
        m1.put(2,"two");
        m1.put(3,"three");
        System.out.println(m1);//{1=one, 2=two, 3=three}
        System.out.println(m1.get(1));//one
        m1.remove(2);
        System.out.println(m1);//{1=one, 3=three},移走
        System.out.println(m1.containsKey(3));//检查是否包含键对象对应的键值对
        System.out.println(m1.containsValue("two"));
        System.out.println(m1.size());//包含键值对的数量
        System.out.println(m1.isEmpty());//检查Map是否为空
        m1.clear();//清空键值对
        System.out.println(m1);
        Map<Integer,String> m2=new HashMap<>();
        m2.put(1,"one");
        m2.put(2,"two");
        m1.putAll(m2);//将m2的所有键值放到m1中
        System.out.println(m1);

    }
}

雇员信息

import java.util.HashMap;
import java.util.Map;

public class testmap2 {
    public static void main(String[]args){
        employee e1=new employee(1,"张三",10000);
        employee e2=new employee(2,"李四",20000);
        employee e3=new employee(3,"王五",30000);

        Map<Integer,employee> m=new HashMap<>();
        m.put(1,e1);
        m.put(2,e2);
        m.put(3,e3);
        System.out.println(m);

    }


}
class employee{
    private int id;
    private String ename;
    private double salary;
    public  employee(int id,String ename,double salary){
        this.id=id;
        this.ename=ename;
        this.salary=salary;
    }
    public String toString(){
        return "id:"+id+" ename:"+ename+" salary："+salary;
    }

}

Map集合的遍历

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class testmap3 {
    public static void main(String[]args){
        Map<Integer,String> m=new HashMap<Integer,String>();
        m.put(1,"张三");
        m.put(2,"李四");
        m.put(3,"王五");
        System.out.println(m.get(1));//张三
        Set<Integer> keyset=m.keySet();
        System.out.println(keyset);//获取所有键的集合，[1, 2, 3]
        for(Integer key:keyset){
            System.out.println(key+","+m.get(key));
        }
        Set<Map.Entry<Integer,String>> entrySet=m.entrySet();
        System.out.println(entrySet);//得到所有键值对的集合
        for(Map.Entry<Integer,String>me:entrySet){
            int key=me.getKey();
            String value=me.getValue();
            System.out.println(key+","+value);
        }
    }
}

码码忽忽

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java周记（第三周）容器

第九章容器数组就是一种容器，可以在其中放置对象或基本类型数据。数组的优势：是一种简单的线性序列，可以快速地访问数组元素，效率高。如果从效率和类型检查的角度讲，数组是最好的。数组的劣势：不灵活。容量需要事先定义好，不能随着需求的变化而扩容。比如：我们在一个用户管理系统中，要把今天注册的所有用户取出来，那么这样的用户有多少个?我们在写程序时是无法确定的。因此，在这里就不能使用数组。基于数组并不能满足我们对于“管理和组织数据的需求”，所以我们需要一种更强大、更灵活、容量随时可扩的容器来装载我们的对
复制链接

扫一扫