目录
使用ArrayList集合，对其添加10个不同的元素，并使用Iterator遍历该集合。
2.使用迭代（即循环）的方式 进行屏幕输入字符或数字，输入内容保存在 ArrayList中，
直到输入#end结束输入，将ArrayList中的内容迭代输出，2种方式，
要求1 输入的内容不能重复，如果ArrayList已经包含输入的内容，
3.使用HashMap实现统计一个字符串中每个字符出现的次数(每个字符作为键，它出现的次数作为值>该题不允许使用String类的方法(除了toCharArrayO)
集合是什么？
集合框架：
底层主要实现数据结构算法----》java方法（功能）、方法使用（增删改查）。
结合框架包含：
概念填空题
数组： 数据类型[]…..
集合：存储Object—任意数据类型的元素
1、JDK中提供了一系列可以存储任意对象的类，统称为 ___集合_______ 。
2、在创建TreeSet对象时，可以传入自定义的比较器，自定义比较器需要实现 Comparator __。
3、Collection有两个子接口分别是List和Set，List集合的特点是 有序可重复 ，Set集合的特点是 无序 不可重复 。
4、使用Iterator遍历集合时，首先需要调用 hasNext() 方法判断是否存在下一个元素，若存在下一个元素，则调用 next() 方法取出该元素。
5、集合按照存储结构的不同可分为单列集合和双列集合，单列集合的根接口是 Collection ，双列集合的根接口是 Map 。
6、Map集合中的元素都是成对出现的，并且都是以 key 、 value 的映射关系存在。
7、List集合的主要实现类有 ArrayList 、 LinkedList ，Set集合的主要实现类有 HashSet 、 TreeSet Map集合的主要实现类有 HashMap 、 TreeMap 。
8、Map集合中存储元素需要调用 put 方法，要想根据该集合的键获取对应的值需要调用 map.get(key)_____ 方法。
9、java.util包中提供了一个专门用来操作集合的工具类，这个类是 Collections ，还提供了一个专门用于操作数组的工具类，这个类是 ____Arrays___ 。
概念判断题
1、Set集合是通过键值对的方式来存储对象的。 错误
2、集合中不能存放基本数据类型，而只能存放引用数据类型。正确
3、如果创建的TreeSet集合中没有传入比较器，则该集合中存入的元素需要实现Comparable接口。正确
4、使用Iterator迭代集合元素时，可以调用集合对象的方法增删元素。错误（正在使用时不能调用）
5、LinkedList在内部维护了一个双向循环链表，每一个元素节点都包含前一个元素节点和后一个元素节点的引用。正确
选择题
1、要想保存具有映射关系的数据，可以使用以下哪些集合？（多选）
A、ArrayList B、TreeMap C、HashMap D、TreeSet
2、Java语言中，集合类都位于哪个包中？
A、java.util B、java.lang C、java.array D、java.collections
3、使用Iterator时，判断是否存在下一个元素可以使用以下哪个方法？
A、next() B、hash() C、hasPrevious() D、hasNext()
4、关于foreach循环的特点，以下说法哪些是正确的？（多选）
A、foreach循环在遍历集合时，无需获得容器的长度
B、foreach循环在遍历集合时，无需循环条件，也无需迭代语句
C、foreach循环在遍历集合时非常繁琐
D、foreach循环的语法格式为：for(容器中元素类型 临时变量 ：容器变量)。
5、在程序开发中，经常会使用以下哪个类来存储程序中所需的配置？
A、HashMap B、TreeSet C、Properties D、TreeMap
6、使用Enumeration遍历集合时，需要使用以下哪些方法？(多选)
A、hasMoreElements() B、nextElement() C、next() D、hashNext()
Vector vector = new Vector();
vector.add(1);
vector.add(2);
vector.add(3);
Enumeration elements = vector.elements();
while (elements.hasMoreElements()) {
Object element = elements.nextElement();
System.out.println(element);
}7、要想集合中保存的元素没有重复并且按照一定的顺序排列，可以使用以下哪个集合？
A、LinkedList B、 ArrayList C、hashSet D、TreeSet
8、下列哪些说法是正确的？（多选）
A、LinkedList集合在增删元素时效率较高
B、ArrayList集合在查询元素时效率较高
C、HashMap不允许出现一对null键null值
D、HashSet集合中元素可重复并且无序
9、以下哪些方法是LinkedList集合中定义的？（多选）
A、getLast() B、getFirst() C、remove (int index) D、next()
10、获取单列集合中元素的个数可以使用以下哪个方法？
A、length() B、size() C、get(int index) D、add(Object obj)
代码实例
ArrayListDemo
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
/**
* @date : 2022/11/21 10:19
*/
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("c");
// arrayList.add(66);
// 有序 可重复
String first = arrayList.get(0);
System.out.println("first:"+first);
String last = arrayList.get(2);
System.out.println("last:"+last);
// 获取arrayList容器中 元素的个数
int size = arrayList.size();
System.out.println(size);
System.out.println("========================");
// 遍历输出集合容器arrayList中的每个元素
// 1）index 0 开始----》arrayList.size()-1
for (int i = 0; i <=arrayList.size()-1; i++) {
String ele = arrayList.get(i);
System.out.println("ele:"+ele);
}
System.out.println("========================");
// 2) foreach增强型循环---代码简洁
/* for(String element:arrayList){
System.out.println("element:"+element);
}*/
// 3)lamda表达式 后面详细讲到
arrayList.forEach(element-> System.out.println(element));
// 4)Iterator迭代器遍历循环
Iterator<String> its = arrayList.iterator();
// 使用Iterator遍历集合时，首先需要调用 hasNext() 方法判断是否存在下一个元素，
// 若存在下一个元素，则调用 next() 方法取出该元素。
while (its.hasNext()) {
String element = its.next();
System.out.println("element:"+element);
}
ArrayList arrayList1 = new ArrayList();
arrayList1.add("hello");
arrayList1.add(12);
// object是String的上转型，在这里可以代替String类型
for(Object ele:arrayList1){
System.out.println("ele:"+ele);
}
/*for(String ele:arrayList1){
System.out.println("ele:"+ele);
}*/
//=================================================
// 使用Enumeration遍历集合
//vector是一个动态数组，可以根据需要动态伸缩
Vector vector = new Vector();
vector.add(1);
vector.add(2);
vector.add(3);
Enumeration elements = vector.elements();
while (elements.hasMoreElements()) {
Object element = elements.nextElement();
System.out.println(element);
}
}
}
结果
ArrayListDemo2的反向输出
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
/**
* 反向输出
* @date : 2022/11/21 10:44
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("demo_1");
list.add("demo_2");
list.add("demo_3");
// Iterator its = list.iterator();
// its.hasNext();
// its.next();
ListIterator it = list.listIterator();
while (it.hasNext()) {
it.next();
}
while(it.hasPrevious()) {
Object obj = it.previous();
System.out.print(obj+" ");
}
}
}
结果
TreeSetDemo
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
*
* @date : 2022/11/21 9:42
*/
public class TreeSetDemo {
public static void main(String[] args) {
// Set set = new TreeSet();
// TreeSet:默认升序机制
//里面类型要一样
TreeSet treeSet = new TreeSet();
treeSet.add(10);
treeSet.add(30);
treeSet.add(20);
treeSet.add(1);
// treeSet.add("hello");
System.out.println(treeSet);
System.out.println("===TreeSet降序==================");
// TreeSet 存放都是Integer类型数据
TreeSet<Integer> treeSet2 = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
//用到插入排序，红黑树
return o2.compareTo(o1);
}
});
treeSet2.add(10);
treeSet2.add(30);
treeSet2.add(20);
treeSet2.add(1);
System.out.println(treeSet2);
System.out.println("===TreeSet元素遍历==================");
TreeSet ts = new TreeSet();
ts.add("b");
ts.add("a");
//唯一性
ts.add("c");
ts.add("c");
Iterator it = ts.iterator();
while (it.hasNext()) {
Object element = it.next();
System.out.println("element："+element);
}
}
}
结果
HashMapDemo
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
*
* @date : 2022/11/21 10:50
*/
public class HashMapDemo {
public static void main(String[] args) {
// 使用泛型 <Integer,String>--规范存储数据得数据类型
// 学号--姓名
Map<Integer,String> map = new HashMap<>();
map.put(100,"CQQ");
map.put(103,"tidy");
map.put(102,"tidy2");
// map存储元素特点： key不可重复 无序
// 根据key 102 修改对应的value值，重复放入会进行覆盖
map.put(102,"tidy66");
// 根据key---获取对应的value值
String value = map.get(103);
System.out.println("value:"+value);
System.out.println("=======================");
// 遍历输出每一对key和value？？
// 1）遍历方式1
Set<Integer> keys = map.keySet();
for(Integer key:keys){
String val = map.get(key);
System.out.println(key+"==============="+val);
}
// 2)遍历方式2
// Map.Entry<Integer, String>将键值封装再一起
Set<Map.Entry<Integer, String>> entries = map.entrySet();
for(Map.Entry<Integer, String> entry :entries){
System.out.println(entry.getKey()+"=============="+entry.getValue());
}
System.out.println("删除操作。。。。。。。。。。");
Map<Integer,String> map2 = new HashMap<>();
map2.put(100,"CQQ");
map2.put(103,"tidy");
map2.put(102,"tidy2");
map2.remove(103);
int size = map2.size();
System.out.println("size:"+size);
Set<Map.Entry<Integer, String>> entries2 = map2.entrySet();
for(Map.Entry<Integer, String> entry :entries2){
System.out.println(entry.getKey()+"=============="+entry.getValue());
}
System.out.println("删除操作。。。。。。。。。。。");
// 删除事项
// 遍历map中元素 如果key是100 删除掉
/*for(Map.Entry<Integer, String> entry :map2.entrySet()){
// System.out.println(entry.getKey()+"=============="+entry.getValue());
if (entry.getKey().equals(100)){
map2.remove(entry.getKey());
}
}*/
boolean flg = false;
for(Map.Entry<Integer, String> entry :entries2){
// System.out.println(entry.getKey()+"=============="+entry.getValue());
if (entry.getKey().equals(100)){
flg=true;
// 如果找到100key 跳出循环
break;
}
}
// flg=true找到这个元素
if(flg){
map2.remove(100);
}
Set<Map.Entry<Integer, String>> entries1 = map2.entrySet();
for(Map.Entry<Integer, String> entry :entries1) {
System.out.println(entry.getKey()+"============="+entry.getValue());
}
}
}
结果
作业
使用ArrayList集合，对其添加10个不同的元素，并使用Iterator遍历该集合。
提示：
1）使用add()方法将元素添加到ArrayList集合中。
2）调用集合的iterator()方法获得Iterator对象，并调用Iterator的hasNext()和next()方法，迭代出
集合中的所有元素。
import java.util.*;
public class test1 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
arrayList.add(4);
arrayList.add(5.2);
arrayList.add(6);
arrayList.add(7);
arrayList.add(8);
arrayList.add(9);
arrayList.add("10");
Iterator it = arrayList.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
结果
2.使用迭代（即循环）的方式 进行屏幕输入字符或数字，输入内容保存在 ArrayList中，
直到输入#end结束输入，将ArrayList中的内容迭代输出，2种方式，
要求1 输入的内容不能重复，如果ArrayList已经包含输入的内容，
提示“已经包含，请继续输入：”。
import java.util.*;
public class test2 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
String str ;
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("请输入:");
str = sc.nextLine();
if (str.equals("#end"))
break;
if (arrayList.contains(str)){
System.out.println("已经包含，请继续输入：");
}
else {
arrayList.add(str);
}
}
}
}
结果
3.使用HashMap实现统计一个字符串中每个字符出现的次数(每个字符作为键，它出现的次数作为值>
该题不允许使用String类的方法(除了toCharArrayO)
import java.util.*;
public class test21 {
public static void main(String[] args) {
HashMap<Character,Integer> hashMap = new HashMap<>();
char[] s = new char[10];
String str ;
Scanner sc = new Scanner(System.in);
str = sc.nextLine();
//toCharArray()将字符串里每个字符分开存入数组
s = str.toCharArray();
// System.out.println(s);
for(char cha : s){
hashMap.put(cha,hashMap.containsKey(cha)?hashMap.get(cha)+1:1);
}
// System.out.println(hashMap);
Set keySet = hashMap.keySet();
Iterator it = keySet.iterator();
while (it.hasNext()){
Object m = it.next();
System.out.println(m+":"+hashMap.get(m));
}
// for (String key:hashMap.keySet()){
// System.out.println(key+":"+hashMap.get(key));
// }
}
}
结果
172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
