java基础---集合

Posted 2021-01-05 流着眼泪奔跑

1-Java集合的特点
Collection接口:不唯一，无序
List接口:不唯一，有序
其中常用类：ArrayList、LinkedList
ArrayList实现了长度可变的数组;遍历元素和随机访问元素的效率比较高
LinkedList采用链表存储方式。插入、删除元素时效率比较高
Set接口：唯一，无序
Map接口：键值对，提供key

接口可以继承接口

2-List集合常用方法

add(Object o) 向列表的尾部追加指定的元素

add(int index,Object o) 在列表的指定位置插入指定元素

get(int index) 返回列表中指定位置的元素

contains(Object o) 如果列表中包含指定的元素，则返回true

remove(int index) 移除列表中指定位置的元素

remove(Object o) 移除列表中出现的首个指定元素

clear() 从列表中移除所有元素

size() 返回列表中的元素数

举例：
//ArrayList的使用
ArrayList alist=new ArrayList();

//添加元素
alist.add("a");
alist.add(1,"b");
alist.add(2,"c");
alist.add(3,"d");
alist.add(4,"e");

//获取集合最后一个元素
Object ob=alist.get(alist.size()-1);
System.out.println("集合中的最后一个元素是："+ob);

//获取集合元素个数
System.out.println("集合元素个数："+alist.size());

//循环迭代集合
for(Object s:alist){
System.out.print(s+" ");
}
System.out.println();

//查看元素
if (alist.contains("c")) {
System.out.println("存在对象");
}else{
System.out.println("不存在");
}

//移除元素
alist.remove(3);
System.out.println("查看移除后的元素");
for(Object s:alist){
System.out.print(s+" ");
}

 

3-ArrayList
添加元素add()
删除元素remove（）
获取元素get（）
修改，先查询对象是否存在，再修改对象的属性

特点，可变数组，查询效率比较高

举例：
//集合中存放的元素默认都是Object
ArrayList alist=new ArrayList();
User u1=new User("u001", "123456");
User u2=new User("u002", "123456");
User u3=new User("u003", "123456");
User u4=new User("u004", "123456");
User u5=new User("u005", "123456");

//添加元素
alist.add(u1);
alist.add(u2);
alist.add(u3);
alist.add(u4);
alist.add(u5);

//获取元素集合
System.out.print("集合元素个数为");
System.out.println(alist.size());

//循环迭代集合
for(Object s:alist){
System.out.println(s+" ");
}
System.out.println();

//获取集合中第3个元素
Object ob=alist.get(2);
//方法一：一般情况，使用父类方法
System.out.println("显示第三个元素");
System.out.println(ob);
//方法二：强制转换
User u=(User)ob;
System.out.println(u.getUname()+","+u.getPassword());
System.out.println();

//移除元素
alist.remove(u3);
System.out.print("移除后元素 ");
for (Object object : alist) {
System.out.println(object);
}
System.out.println();

//查看元素
System.out.print("是否存在u2？");
if (alist.contains(u2)) {
System.out.println("存在对象");
}else{
System.out.println("不存在");
}

//查看集合中是否存在名称为u004的User对象，如果存在，修改密码为888888
for (int i = 0; i <alist.size(); i++) {
User use=(User) alist.get(i);
if (use.getUname().equals("u004")) {
System.out.println("元素存在，修改密码");
use.setPassword("888888");
System.out.println("修改密码成功");
break;
}
}

//查看修改完的集合中元素
for(Object s:alist){
System.out.println(s+" ");
}

4-LinkedList：插入、删除元素时效率比较高

addFirst(Object o) 将给定元素插入此列表的开头

addLast(Object o) 将给定元素追加到此列表的结尾

getFirst() 返回此列表的第一个元素

getLast() 返回此列表的最后一个元素

reomveFirst() 移除并返回此列表的第一个元素

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

父类的声明子类的实现，不能调用子类的方法

举例：
LinkedList list=new LinkedList();

User u1=new User("u001","123456");
User u2=new User("u002","123456");
User u3=new User("u003","123456");
User u4=new User("u004","123456");
User u5=new User("u005","123456");

//添加元素
list.add(u1);
list.add(u2);
list.addFirst(u3);//添加第1个索引位置
list.addLast(u4);//添加到最后一个索引位置，但是后面添加的元素将在该元素后面
list.add(u5);

System.out.println("linkedList的第一个元素： "+list.getFirst()+","+list.get(0));
System.out.println("查看集合所有元素");
for (Object ob : list) {
System.out.println(ob);
}

//移除元素
System.out.println("移除元素");
list.removeLast();//移除最后一个元素
for (Object ob : list) {
System.out.println(ob);
}

5-Set集合
存储的元素是无序的、不可重复的

主要实现类：
HashSet：可以添加null值，线程不安全
LinkedHashSet：遍历时效率比较高
TreeSet：存入的元素需要排序，按照指定的顺序遍历

举例：
// set集合无序，不可重复
Set set=new HashSet();
set.add("呵呵");
set.add("呵呵");
set.add("cc");
set.add("哈哈");
System.out.println("集合大小:"+set.size());

//如何获取集合元素？迭代set集合元素
Iterator it=set.iterator();

while(it.hasNext()){
String s=(String)it.next();
System.out.print(s+" ");
}

6-Map接口

1)Map用于保存具有映射关系的数据（key-vlaue）。
Map的key不允许重复

Map实现类：HashMap、LinkedHashMap、
TreeMap、Hashtable(Properties)
2)接口常用方法
Object put(Object key, Object val) 以“键-值对”的方式进行存储
Object get (Object key) 根据键返回相关联的值，如果不存在指定的键，返回null
Object remove (Object key) 删除由指定的键映射的“键-值对”
int size() 返回元素个数
Set keySet () 返回键的集合
Collection values () 返回值的集合
booleancontainsKey(Object key) 如果存在由指定的键映射的“键-值对”，返回true

举例：
//创建Map的实例
Map<String,String> map=new HashMap<String,String>();

//添加数据到map中
map.put("s001", "tom");
map.put("s002", "lucy");
map.put("s002", "lily");


//map中key不可重复
System.out.println("map大小:"+map.size());


//获取map中元素,需要强转
String s2=(String)map.get("s002");
System.out.println("获取map中元素："+s2);


//判断集合中是否存在某个key
if (map.containsKey("s001")) {
System.out.println("s001存在");
}

//判断集合中是否存在某个value
if(map.containsValue("lily")){
System.out.println("value:lily存在 ");
}

//获取key集合
Set<String> set=map.keySet();
System.out.println("循环打印key的集合");
Iterator<String> it=set.iterator();
while (it.hasNext()) {
System.out.print(it.next()+" ");

}

//获取value集合
System.out.println(" 循环打印value值的集合");
Collection<String> values=map.values();//map中value的集合
Iterator<String> it2=values.iterator();
while(it2.hasNext()){
System.out.print(it2.next()+" ");
}

3)Map遍历
迭代器Iterator实现遍历
增强性for循环

7-泛型集合
解决强制类型转换时容易出现的异常问题
保证了数据的安全
使用泛型不需要墙砖

举例：
Map<String,User> map=new HashMap<String,User>();
//添加
map.put("u001",new User("admin","admin"));
map.put("u002",new User("user","user"));

//获取map中元素的键
User u= (User)map.get("u002");


//增强型for迭代key的集合
for (String key:map.keySet()) {
System.out.println("key="+key);
System.out.println("value="+map.get(key));
}

//增强型for迭代value的集合
for (User value:map.values()) {
System.out.println(value);
}

 

 

举例：public static void main(String[] args) {
HashMap<String, String> hmap=new HashMap<String, String>();
hmap.put("1001", "学生A");
hmap.put("1002", "学生B");
hmap.put("1003", "学生C");
Set<String> keySet=hmap.keySet();//获取键的集合
Collection<String> values=hmap.values();//获取值的集合
for(String sno:hmap.keySet()){
System.out.println(hmap.get(sno));
}
}