集合
集合: 集合和数组不一样，数组的元素可以是基本数据类型，也可以是对象(实际上保存的是对象的引用变量)。
集合是只能存储对象(存储的也是对象的引用变量)。
Iterator
Iterator 隐藏了各种Collection实现类的底层细节。向应用程序提供了遍历集合的统一编程接口。
Iterator 接口中定义的方法:
+ HasNext() 如果仍有元素可以迭代，则返回 true。
+ next() 返回迭代的下一个元素
+ remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
注意: Iterator 是依赖于集合存在的，离开和集合Iterator是没有什么用的。
在JDK1.2 之后使用迭代器替换了Enumeration.(添加remove()方法，修改方法名。)
Collection collection = new ArrayList();
collection.add("Hello");
collection.add(123);
collection.add('s');
collection.add(123.45);
Iterator it = collection.iterator();
//hasNext()方法带有判断功能 所以使用while循环更方便。
while(it.hasNext()){
Object obj = it.next();
System.out.println(onj);
}
Collection
Collection是集合的根接口，存储数据，允许有重复的，不重复的。可以允许null元素，也有不允许null元素。
Collection还提供了一些操作集合的方法
- add() 像集合中添加元素
- addAll(Collection collection) 将传递的集合中所有元素添加到集合的末尾
- size() 集合中元素的个数
- remove() 移除元素
- contains() 是否包含某个元素
- clear() 清除集合中的元素
- isEmpty() 判断集合是否为空
- equals() 判断集合对象是否想到
- hashCode() 返回集合的哈希码
- iterator() 返回集合的迭代器
List
有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。此集合允许有重复的元素(equals()判断相等的对象)，允许有多个null元素。
List集合在Collection集合接口提供的方法之上，添加了一些其他的方法:
+ get() 通过下标访问集合元素
+ indexOf() 返回元素在集合中第一次出现的索引。
+ lastIndexOf() 返回元素在集合中最后一次出现的索引。
+ listIterator() 返回list集合的列表迭代器。
+ set(int index,Element e) 替换下标为的元素
+ subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
List集合的四种遍历方式:
List list = new ArrayList();
list.add("HelloWorld");
list.add(123);
list.add('a');
list.add(1234.44);
list.add(new Object());
//普通for循环遍历
for(int i =0;i<list.size();i++){
System.out.println(list.get(i));
}
//增强for循环
for(Object obj : list){
System.out.println(obj);
}
//iterator 迭代器遍历
Iterator it = collection.iterator();
//hasNext()方法带有判断功能 所以使用while循环更方便。
while(it.hasNext()){
Object obj = it.next();
System.out.println(onj);
}
//listIterator 遍历
ListIterator it = collection.listIterator();
//hasNext()方法带有判断功能 所以使用while循环更方便。
while(it.hasNext()){
Object obj = it.next();
System.out.println(onj);
}
ArrayList
List 接口的大小可变数组的实现。底层是数组结构
ArrayList的特点:
+ 底层是数组结构
+ 有序的列表，如何添加的顺序，如何获取
+ 线程不安全，不同步
+ 增删慢，查询快
+ 允许元素重复，允许多个null元素
ArrayList list = new ArrayList();
list.add("HelloWorld");
list.add(123);
list.add('a');
list.add(1234.44);
list.add(new Object());
//["HelloWorld",123,'a',123.44,java.lang.Object@23e4e5]
System.out.println(list);
for(Object obj : list){
System.out.println(obj);
}
//使用remove方法一处元素
ListIterator it = list.listIterator();
//hasNext()方法带有判断功能 所以使用while循环更方便。
while(it.hasNext()){
Object obj = it.next();
//使用集合对象移除元素会发生:ConcurrentModificationException 并发修改异常 不能同时对集合元素操作
//list.remove();
//使用迭代器来进行移除元素，同一个对象进行操作就可以
it.remove();
System.out.println(onj);
}
泛型
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）
ArrayList <Object> list = new ArrayList<Object>();
list.add("HelloWorld");
list.add(123);
list.add('a');
list.add(1234.44);
list.add(new Object());
//["HelloWorld",123,'a',123.44,java.lang.Object@23e4e5]
System.out.println(list);
for(Object obj : list){
System.out.println(obj);
}
//添加泛型以后再添加其他数据类型的数据就会出现错误
ArrayList<String> list = new ArrayList<String>();
list.add("HelloWolrd");
list.add("admin");
list.add("joke");
list.add("Java");
//迭代器没有添加泛型 取出的元素就是Object 在使用时就要强转。
Iterator it = list.iterator();
while(it.hasNext()){
String ss = (String)it.next();
System.out.println(ss);
}
//增强for循环遍历
for(String str : list){
System.out.println(str);
}
//迭代器遍历 迭代器指定泛型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String ss = it.next();
System.out.println(ss);
}
//添加自定义类的对象
ArrayList<Person> list = new ArrayList<Person>();
list.add(new Person(12,"admin"));
list.add(new Person(23,"java"));
list.add(new Person(44,"joke"));
//增强for循环
for(Person person : list){
System.out.println(person);
}
//迭代器遍历
Iterator<Person> it = list.iterator();
while(it.hasNext()){
Person pserson = it.next();
System.out.println(person);
}
LinkedList
List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。
- 底层的数据结构是链表
- 线程不安全的，不是同步的
- 增删快，查询慢。
- 有序的链表，怎么添加，怎么取出
LinkedList 的特点:
LinkedList<String> list = new LinkedList<String>();
list.add("HelloWorld");
list.add("Java");
list.add("admin");
list.add("joke");
//["HelloWorld","Java","admin","joke"]
System.out.println(list);
// 普通for循环遍历
for(int i =0;i<list.size();i++){
System.out.println(list.get(i));
}
Set
Set集合特点
- 输出值无序的（存储和读取的顺序不一样）
- 不允许重复，要求元素唯一。
- 没有索引
- add:方法 添加元素
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
HashSet
底层是哈希表:实际上是一个 HashMap 实例
无序的。
不允许元素重复，
最多只有一个null值。
不是同步的。不安全。
public class SetTest {//创建集合对象
public static void main(String[] args) {
//method1();
//method2();
}
public static void method1(){
Set<Person> set = new HashSet<Person>();
set.add(new Person(12,"admin"));
set.add(new Person(12,"admin"));
set.add(new Person(12,"admin"));
//[Person{age=12, name='admin'}, Person{age=12, name='admin'}, Person{age=12, name='admin'}]
System.out.println(set.toString());
//可以去除重复元素呀？为什么还是三个？怎么解决重复？
//重写equals() 和 hashCode()
//[Person{age=12, name='admin'}]
}
//几种遍历方式? 2种 增强for循环 迭代器
public static void method2(){
Set<Integer> set = new HashSet<Integer>();
set.add(123);
set.add(223);
set.add(2323);
set.add(26523);
//为什么不行?
/*for (int i = 0; i < set.size(); i++) {
System.out.println(set.);
} */
for (Integer integer : set) {
System.out.println(integer);
}
Iterator<Integer> iterator = set.iterator();
while(iterator.hasNext()){
//自动拆箱
int num = iterator.next();
System.out.println(num);
}
}
}
TreeSet
基于 TreeMap 的 NavigableSet 实现（二叉树）。使用元素的自然顺序对元素进行排序，
或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
1. 自然排序
Comparable
* 自定义类实现自然排序。
2.比较器排序
TreeSet(Comparator<? super E> comparator)
构造一个新的空 TreeSet，它根据指定比较器进行排序。
匿名内部类实现。
原则:
使用排序的时候首先定义主要的规则。
然后再根据主规则定义其他的规则。
public class TreeSetTest {
public static void main(String[] args) {
//method1();
method2();
}
public static void method1(){
TreeSet<Person> treeSet =new TreeSet<>();
treeSet.add(new Person(23,"admin"));
treeSet.add(new Person(13,"joke"));
treeSet.add(new Person(13,"set"));
treeSet.add(new Person(35,"java"));
treeSet.add(new Person(45,"java"));
// com.hdrj.set.Person cannot be cast to java.lang.Comparable
System.out.println(treeSet);
主规则 按年龄
//[Person{age=13, name='joke'}, Person{age=23, name='admin'},
// Person{age=35, name='java'}, Person{age=45, name='java'}]
//年龄相等看名字
/* [Person{age=13, name='joke'}, Person{age=13, name='set'}, Person{age=23, name='admin'},
Person{age=35, name='java'}, Person{age=45, name='java'}]*/
}
//比较器排序
public static void method2(){
TreeSet<Student> treeSet = new TreeSet<>(
//匿名内部类
new Comparator<Student>() {
@Override
public int compare(Student student1, Student student2) {
// count
// address
//price
int num = student1.getCount()-student2.getCount();
int num2 = num==0 ? student1.getAddress().compareTo(student2.getAddress()):num;
return num2==0? (int)(student1.getPrice()-student2.getPrice()):num2;
}
}
);
treeSet.add(new Student(23,"西安",2200.00));
treeSet.add(new Student(43,"北京",2200.00));
treeSet.add(new Student(77,"上海",456.00));
treeSet.add(new Student(89,"兰州",99.00));
treeSet.add(new Student(23,"西安",333.00));
//Student{count=23, address='西安', price=2200.0},
System.out.println(treeSet);
}
}
HashSet
底层是哈希表：事实上是一个HashMap实例
- 无序的
- 不允许重复
- 最多只有一个null值
- 不是同步的，不安全
TreeSet
基于TreeMap的NavigableSet实现（二叉树），使用元素的自然顺序对元素进行排序，或许根据创建set时提供的Comoarator进行排序，具体取决于使用的构造方法
1.自然排序
Comparable
自定义类实现自然排序
2.比较器排序
TreeSet（Comparator<?super E>comparator）
构造一个新的空TreeSet，它根据指定比较器进行排序。
匿名内部类实现。‘
原则：
使用排序的时候首先自定义主要的规则
然后再根据主规则定义其他的规则
Map
将键映射到值得对象，一个映射不能包含重复得键
每一键最多只能映射到一个值
允许以键集，值集或键-值映射关系集得形式查看某个映射得内容
Set keySet() 获取键得Set视图
get（key）通过键获取值
values()；获取键得Set视图
Set<Map.Entey<K,V>>entrySet();获取Map集合得键值对映射关系
Map集合的遍历方式；
常用的有俩种：
1.获取键的Set视图，在通过get（key）获取键对应的值
Set<Integer> set = map.keySet();
Iterator<Integer> iterator = set.iterator();
while(iterator.hasNext()){
int key = iterator.next();
String value = map.get(key);
System.out.println(value);
}
2.获取集合的键值映射关系视图Map.Entry<K,V>再通过
getKey()获取键，getValue（）获取值
Set<Map.Entry<Integer,String>> set = map.entrySet();
Iterator<Map.Entry<Integer,String>> iterator = set.iterator();
while(iterator.hasNext()){
//键值映射关系
Map.Entry<Integer,String> en = iterator.next();
int key = en.getKey();
String value = en.getValue();
System.out.println("key=="+key+"----value="+value);
}
扫一扫
703
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
