集合是一种动态的对象数组，数据各个数据结构的实现类，在整个类集之中主要的组成是一些核心的操作接口：Collection，List,Set,Map,Iterator

1 Collection 接口

常用方法：

public boolean add(E e)  数据增加
public void clear() 清除数据
public boolean remove(Object o) 删除数据
public boolean contains(Object o) 查找数据是否存在
public boolean isEmpty() 判断是否为空集合
public int size()  取得集合的个数
public Object[] toArray() 将集合变为对象数组
public Iterator<E> iterator() 为Iterator接口实例化

Collection几乎不用，使用Collection的两个子接口：List、Set

2 List 接口

定义：public interface List<E> extends Collection<E>

方法：List接口实现了对Collection接口进行扩充，主要方法有：

public E get(int index)  取得指定索引位置上的数据
public E set(int index, E element)  修改指定索引位置上的数据
public ListIterator<E> listIterator() 为ListIterator接口实例化

实现类：ArrayList,LinkedList,Vector

ArrayList类：List接口最常用类：

public class ArrayList<E>  extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

使用ArrayList: List 集合之中即使存在了重复数据，也可以正常保存，而且数据保存的顺序就是存入数据的顺序。

List<String> all = new ArrayList<String>() ;all.add("Hello") ; all.add("Hello") ;  // 内容重复了all.add("World") ;for (int x = 0; x < all.size(); x++) {String str = all.get(x) ;   // get()方法只有List接口有System.out.print(str + "、");
}

数组与集合的转换

数组转换为集合：Arrays.asList()

String[] str = {"1","2","3","4","1","2","1"};
List<String> list = Arrays.asList(str);

注：使用Arrays.asList得到的集合无法使用add，remove方法：

解决：生成新的list

List<String> list = Arrays.asList("1","2","3");
List<String> lists = new ArrayList<>(list);

集合转换为数组：list.toArray()

List<String>  list = new ArrayList<>();
list.add("张三");
list.add("李四");
Object[] str = list.toArray(); //使用Object接收

注意：在转化为其它类型的数组时需要强制类型转换，并且，要使用带参数toArray方法，参数为对象数组

String[] strs = (String[])list.toArray(new String[0]);

添加：addAll 和add

add添加一个元素进list里，addAll是添加一个集合，将集合里的所有元素添加到list里addAll(Colllection c)

List<String>  list = new ArrayList<>();
list.add("张三");
list.add("李四");
System.out.println(Arrays.toString(list.toArray())); //[张三，李四]
List<String> list2 = new ArrayList<>();
list2.add("1");
list2.add("2");
list.addAll(list2);
System.out.println(Arrays.toString(list.toArray())); //[张三，李四，1,2]

删除：clear,removen,removeAll

clear()是清除数据，remove()是删除数据（传入元素，或索引） removeAll()删除所有传入的是集合对象。

list.remove(person1); //删除某个元素
list.remove(2);  //根据索引删除
list.clear();         //删除所有
list.removeAll(list);  //删除所有 //传入的集合 Collections
List<Persons> item = new ArrayList<>();
item.add(person3);
list.removeAll(item);

删除符合条件的：(注意不能使用for循环里面使用remove()删除）

1.使用Iterator

Person p1 =new Person("1","张三","1234",13,new BigDecimal("60"));
Person p2 =new Person("2","李四","1111",16,new BigDecimal("60"));
Person p3 =new Person("3","王五","1112",22,new BigDecimal("60"));
List<Person> list = new ArrayList<>();
list.add(p1);list.add(p2);list.add(p3);
for (Iterator<Person> iter = list.iterator(); iter.hasNext();) {Person person = iter.next();if (person.getAge() <20) {iter.remove();}
}

2.将要删除的放到新集合里

List<Person> listremove = new ArrayList<>();
for(Person person :list){if(person.getAge()<20){ listremove.add(person);}
}
list.removeAll(listremove);
System.out.println(list.size());

循环遍历

list输出方式三种：Iterator,forEach,for :list有get()方法

1.迭代输出Iterator

Iterator 为集合输出接口，定义的方法有：

·判断是否有下一个元素：public boolean hasNext();

·取得下一个元素：public E next();

取得Iterator接口的实例化对象，在Collection接口中定义，Collection继承了一个Iterable接口，接口下有个方法：public Iterator<T> iterator(),取得Iterator接口的实例化对象

List m = Arrays.asList("one two three four five".split(" "));
Iterator<String> iter = m.iterator();
while(iter.hasNext()){String str = iter.next();System.out.println(str);
}

2. foreach输出：

List<String> m = Arrays.asList("one two three four five".split(" "));
for (String str:m) {System.out.println(str);
}

3. get输出：

List<String> m = Arrays.asList("one two three four five".split(" "));
for(int i =0;i<m.size();i++){System.out.println(m.get(i));
}

集合排序：

集合排序使用Comparable接口和Compartor接口：

Comparable接口：

List<User> users = new ArrayList<>();
users.add(new User(1,"张三",17,70.0));users.add(new User(2,"李四",20,79.0));
users.add(new User(3,"王五",18,60.0));users.add(new User(4,"赵六",21,70.0));
Collections.sort(users);
for (User user:users) {  System.out.println(user.getId()+"/"+user.getUsername()
+"/"+user.getAge()+"/"+user.getGrade());
}//注意：sort(List<T>)方法中List中的T必须实现Comparable<T>接口，并且实现compareTo()方法
@Override
public int compareTo(User o) {int i =this.getAge()-o.getAge();return i;
}

Compartor接口：

//Collections的第二种排序方法sort(List<T> list,Comparator<? super T> c)
Collections.sort(list, new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {int i =o1.getAge()-o2.getAge();return i;}
});
// list.sort()
list.sort(new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {int i =o1.getAge()-o2.getAge();return i;}
});

Set接口：set接口用的少：

public interface Set<E> extends Collection<E>

Set使用：Set不允许重复数据，保存的数据没有重复并且有序排列
Set<String> all = new HashSet<String>() ;all.add("Hello") ;all.add("Hello") ;  // 内容重复了all.add("World") ;System.out.println(all);

Map接口：

Map使用：Map接口是偶对象保存，数据以键值对的方式存储,通过key可以找到对应的value数据

Map方法：

public V put(K key, V value)    向集合之中保存数据
public V get(Object key)        通过指定的key取得对应的value
public Set<K> keySet()          将Map中的所有key以Set集合的方式返回
public Set<Map.Entry<K,V>> entrySet()   将Map集合变为Set集合

Map接口常用子类：HashMap,Hashtable

Map<String,String> map = new HashMap<>();
map.put("1","张三");
map.put("2","李四");
map.put("3","王五");
map.put(null,"赵六");
System.out.println(map.get("3"));
System.out.println(map.get(null));

注意：Map和Collection操作的不同

Collection接口设置完的内容目的是为了输出

Map接口设置完内容的目的是为了查找

Map.Entry接口

Map中没有Iterator()方法，Map.Entry接口定义：

public static interface Map.Entry<K,V>
取得当前的key：public K getKey();
取得当前的value：public V getValue();

注意：map集合和Collection集合之中保存的最大区别：Collection直接保存要操作对象，Map集合是将保存的key和value变成一个Map.Entry对象，通过这个对象保存了key 和Value后保存的。

使用Iterator输出：使用Map的entrySet()方法吧集合变为Set集合

取得了Set接口实例后可以利用Iterator()方法取得Iterator的实例化对象；

使用Iterator迭代到每个Map.entry对象，并进行key和value的分离；

范例：使用Iterator对Map输出

Map<Integer, String> map = new Hashtable<Integer, String>();
map.put(3, "张三");map.put(3, "李四"); // key重复，value会被新内容覆盖
map.put(1, "王五");map.put(0, "赵六");
Set<Map.Entry<Integer, String>> set = map.entrySet();
Iterator<Map.Entry<Integer, String>> iter = set.iterator();
while (iter.hasNext()) {Map.Entry<Integer, String> me = iter.next();System.out.println(me.getKey() + "，" + me.getValue());
}

map实现遍历方法：

Map<String,String>  map = new HashMap<>();
map.put("1","张三");map.put("2","李四");
map.put("3","王五");map.put("4","赵六");
//keySet方法：获取所有key,遍历key，根据key取value
for(String strkey:map.keySet()){String strvalue=map.get(strkey);System.out.println(strkey+" : "+strvalue);
}
-------------------------------------------------------------------------------
//使用Iterator 通过entrySet()方法
Iterator<Map.Entry<String,String>> iter = map.entrySet().iterator();
while(iter.hasNext()){Map.Entry<String,String> entry = iter.next();System.out.println(entry.getKey()+" : "+entry.getValue());
}
//forEach 遍历Map.Entry<String,String>
for(Map.Entry<String,String> entry:map.entrySet()){System.out.println(entry.getKey()+" : "+entry.getValue());
}
-------------------------------------------------------------------------------
//Map.values()方法
for(String value:map.values()){System.out.println("value"+" : "+value);
}

public boolean containsKey(Object key)

该方法判断Map集合对象中是否包含指定的键名：如果Map集合中包含指定的键名，返回true，否则返回false

public boolean containsValue(Object value)

第三章 java集合相关推荐

第三章 Java Servlet基础
第三章 Java Servlet基础 3.6.2 转发 1．获得RequestDispatcher对象 2．RequestDispatcher对象调用forward()方法实现转发请求转发工作原理 ...
CoreJava 笔记总结-第三章 Java的基本程序设计结构
CoreJava 笔记总结文章目录 CoreJava 笔记总结第三章 Java的基本程序设计结构数据类型 1. 整型 2. 浮点类型 3. char类型 4. boolean类型变量与常量 1 ...
java泛型 ppt_第7章-Java集合与泛型-精品课件（PPT）-精品课件（PPT）最新版
<第7章 -Java集合与泛型-精品课件(PPT)-精品课件(PPT).ppt>由会员分享,可免费在线阅读全文,更多与<第7章 -Java集合与泛型-精品课件(PPT)-精品课件(P ...
第三章. Java反射
第三章. Java反射 1. 反射 2. 反射接口 2.1获取Class方式: 2.2 获取成员变量并调用 2.3 获取成员方法并调用 2.4 获取构造方法并调用 2.5 获取父类信息 3. 反射应用 ...
Java SE第8章 Java集合
Java SE第8章 Java集合 1. 集合的概念和作用 2. 使用Lambad表达式遍历集合 3.Collection集合的常规用法 4. 使用Predicate操作集合 5.使用Iterator ...
Java学习总结之第十一章 Java集合
一.总结 1. 所有Java集合类都位于java.util包中,与Java数组不同,Java集合中不能存放基本数据类型,只能存放对象的引用. 2. Set.List.Map统称为Java集合. 3. ...
【Java基础系列教程】第三章 Java变量与运算符
一.Java程序基本结构 1.1 基本结构 Java程序基本结构示例代码: /** * 这里是文档注释 * 这是一个HelloWorld程序 */ public class HelloWorld {p ...
Java并发编程 - 第三章 Java内存模型
前言: Java 线程之间的通信对程序员完全透明,内存可见性问题很容易困扰 Java 程序员,本章将揭开 Java 内存模型神秘的面纱. 一.Java 内存模型的基础 1.1 并发编程模型的两个关键问 ...
第三章 Java基础（二）
文章目录 (八)Java的反射机制 1.什么是反射?--框架设计的灵魂 2.字节码Class对象 3.反射机制 (3.1)类成员变量的反射 (3.2)类成员方法的反射 (3.3)类构造方法的反射 (3 ...

第三章 java集合

1 Collection 接口

2 List 接口

第三章 java集合相关推荐

最新文章

热门文章