集合
2019-06-10 本文已影响0人
Dujf
1. ListDemo
package _1;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Vector;
/**
* Collection接口:用于储存单个对象的集合
* List接口:
* 1.有序的,可以重复的
* 2.允许多个null元素
* 3.具体的实现类常用的有: ArrayList,Vector,LinkedList
*
* 在实际开发中,如何选择List的具体实现类?
* 1. 安全性问题(线程)
* 2. 是否频繁插入,删除操作(LinkList)
* 3. 是否是储存后遍历
*
* @作者 feng
* @创建时期: 2019年6月3日
* @描述:
*/
public class ListDemo {
/**
* LinkedList
* 1. 实现原理,采用双向链表实现
* 2. 适合插入,删除操作,性能高
*/
public static void linkedlist() {
LinkedList<String> L = new LinkedList<>();
L.add("du");
L.add("jia");
L.add("feng");
for (int i = 0; i < L.size(); i++) {
System.out.println(L.get(i));
}
}
/**
* Vector
* 1. 实现原理: 采用动态数组实现,默认构造方法创建了一个大小为10的对象数组
* 2. 扩充的算法:当增量小于等于0时,扩充为原来大小的2倍,当增量大于0时,扩充为原来大小+增量
* 3. 不适合删除或插入操作
* 4. 为了防止数组动态扩充次数过多,建议创建时给定初始容量
* 5. 线程安全,适合多线程使用,效率比较低
*
* 面试题: Vector和ArrayList的区别?
*/
public static void vector() {
Vector<String> v = new Vector<>();
v.add("du");
v.add("jia");
v.add("feng");
for (int i = 0; i < v.size(); i++) {
System.out.println(v.get(i));
}
}
/**
* ArrayList
* 1.实现原理,采用动态数组对象实现,默认构造方法创建了一个空数组
* 2.第一次添加元素,扩充容量为10,之后扩充为原来的1.5倍
* 3.不适合删除或插入操作
* 4.为了防止数组动态扩充次数过多,建议创建时给定初始容量
* 5.线程不安全,适合在单线程中使用
* JDK1.2开始引入
*/
public static void arraylist() {
//使用集合来存储多个不同类型的元素(对象),那么在处理时会比较麻烦,
//实际开发中,不建议这样使用,我们应该在一个集合中存储相同类型的数据
ArrayList<String> list = new ArrayList<>();
list.add("du");
list.add("jia");
list.add("feng");
//遍历集合
int size = list.size();
for (int i = 0; i < size; i++) {
System.out.println(list.get(i));
}
System.out.println(list.contains("du"));
list.remove("du");
System.out.println(list.size());
String[] array = list.toArray(new String[] {});
for(String s:array) {
System.out.println(s);
}
}
public static void main(String[] args) {
arraylist();
//vector();
//linkedlist();
}
}
2 .setDemo
package _1;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
/**
* Set接口
* 1.无序的(不保证顺序)
* 2.不允许重复元素
* 3.HashSet, TreeSet, LinkedHashset
*
* 如果要排序,选择TreeSet
* 不排序的话,选择HashSet
* 如果不排序,但是要保证有一定顺序,选择LinkedHashSet
* @作者 feng
* @创建时期: 2019年6月6日
* @描述:
*/
public class SetDemo {
/**
* 哈希表和链表的实现,
* 维护着一个运行于所有条目的双重链表列表,此链接列表定义了迭代顺序,即按照将元素插入到set中的顺序(插入顺序)进行迭代
*
*/
private static void linkedhashSet() {
Set<Cat> set = new LinkedHashSet<>();
Cat c1 = new Cat("miaomiao",1,1);
Cat c2 = new Cat("喵喵",3,2);
Cat c3 = new Cat("花花",2,3);
Cat c4 = new Cat("huahua",2,4);
set.add(c1);
set.add(c2);
set.add(c3);
set.add(c4);
for(Cat c:set) {
System.out.println(c);
}
}
/**
* 有序的,基于TreeMap(二叉树数据结构),对象需要比较大小,通过对象比较器来实现,
* 对象比较器还可以用来去掉重复元素,如果自定义的数据类,没有实现比较器接口,将无法添加到Treeset集合中
*/
private static void treeSet() {
Set<Cat> tree = new TreeSet<>(new CatComparator());
Cat c1 = new Cat("miaomiao",1,1);
Cat c2 = new Cat("喵喵",3,2);
Cat c3 = new Cat("花花",2,3);
Cat c4 = new Cat("huahua",2,4);
tree.add(c1);
tree.add(c2);
tree.add(c3);
tree.add(c4);
System.out.println(tree.size());
for(Cat c:tree) {
System.out.println(c);
}
}
/**
* Hashset
* 1. 实现原理,基于哈希表(HashMap)实现
* 2. 不允许重复,可以有一个NULL元素
* 3. 不保证顺序恒久不变
* 4. 添加元素时把元素作为HashMap的key存储,HashMap的value使用一个固定的object对象
* 5. 排除重复元素是通过equals来检查对象是否相同
* 7. 自定义对象时要认为属性值都相同的对象为同一对象,有这种需求时,我们要重写hashcode()和equals()方法
*
*
* 小结
* (1) 哈希表的存储结构: 数组+链表,数组里的每个元素以链表的形式存储
* (2) 如何把对象存储到哈希表中,先计算对象的hashcode值,再对数组的长度求余数,来决定对象要存储在数组中的哪个位置
* (3) 解决hashset中的重复值使用的方式是,参考附件
*/
private static void hashSet() {
Set<String> set = new HashSet<>();
set.add("刘备");
set.add("关羽");
set.add("刘备");
set.add("诸葛亮");
set.add("赵云");
System.out.println(set.contains("刘备"));
String[] names = set.toArray(new String[] {});
for(String i:names) {
System.out.println(i);
}
Cat c1 = new Cat("miaomiao",1,1);
Cat c2 = new Cat("喵喵",3,2);
Cat c3 = new Cat("花花",2,3);
Cat c4 = new Cat("huahua",2,4);
Set<Cat> setCat = new HashSet<>();
setCat.add(c1);
setCat.add(c2);
setCat.add(c3);
setCat.add(c4);
//setCat.add(c1);
for(Cat c:setCat) {
System.out.println(c);
}
System.out.println("c1="+c1.hashCode()%16);
System.out.println("c2="+c2.hashCode()%16);
System.out.println("c3="+c3.hashCode()%16);
System.out.println("c4="+c4.hashCode()%16);
}
public static void main(String[] args) {
//hashSet();
//treeSet();
linkedhashSet();
}
}
3 . IteratorDemo
package _1;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
* 集合的输出(迭代)
* @作者 feng
* @创建时期: 2019年6月10日
* @描述:
*/
public class IteratorDemo {
//断言接口
private static void predicateTest() {
List<String> lists = Arrays.asList("内蒙古IMUST","科技","大学SD");
List<String> result = fiter(lists,(s)->s.contains("I"));
result.forEach(System.out::print);
}
private static List<String> fiter(List<String> list,Predicate<String> p){
List<String> results = new ArrayList<>();
for(String s:list) {
if(p.test(s)) { //测试是否符合要求
results.add(s);
}
}
return results;
}
//supplier 表示结果供应商
private static void supplierTest() {
List<Integer> list = getNums(10, ()->(int)(Math.random()*100));
// list.forEach(System.out::println);
for(Integer i:list) {
System.out.println(i);
}
}
private static List<Integer> getNums(int num,Supplier<Integer> sup) {
List<Integer> list = new ArrayList<>();
for(int i=0;i<num;i++) {
list.add(sup.get());
}
return list;
}
//表示接收一个参数并产生结果的一个函数
private static void function() {
String s = strToUpp("dujiafeng", (str)->str.toUpperCase());
System.out.println(s);
}
public static String strToUpp(String str,Function<String, String> f) {
return f.apply(str);
}
/**
* JDK1.8新的迭代方法
*/
private static void foreach() {
List<String> list = new ArrayList<>();
list.add("内蒙古");
list.add("科技大学");
list.add("信息工程学院");
list.forEach((String s)->{System.out.println(s);});
}
private static void enumeration() {
Vector<String> vs = new Vector<>();
vs.add("内蒙古");
vs.add("科技大学");
vs.add("信息工程学院");
Enumeration<String> es = vs.elements();
while(es.hasMoreElements()) {
System.out.println(es.nextElement() );
}
}
//foreach (1.5之后)
private static void foreach(Collection<Cat> c) {
for(Cat cat:c) {
System.out.println(cat.toString());
}
}
//iterator (1.5之前统一的迭代集合方式)
private static void iterator(Collection<Cat> c) {
Iterator<Cat> iter = c.iterator();
while(iter.hasNext()) {
System.out.println(iter.next());
}
}
public static void main(String[] args) {
// List<Cat> list = new ArrayList<>();
// Cat c1 = new Cat("miaomiao",1,1);
// Cat c2 = new Cat("喵喵",3,2);
// Cat c3 = new Cat("花花",2,3);
// Cat c4 = new Cat("huahua",2,4);
// list.add(c1);
// list.add(c2);
// list.add(c3);
// list.add(c4);
// foreach(list);
// iterator(list);
// foreach();
//function();
//supplierTest();
predicateTest();
}
}
注意:
hashCode深入分析
hashcode()方法,在object类中定义如下:
public native int hashCode();
hashcode是本地方法,他的实现是根据本地机器相关,当然我们可以在自己写的类中覆盖hashcode()方法,比如String,Integer,Double....等等这些类都是覆盖了hashcode()方法的
在Java的集合中,判断两个对象是否相等的规则是:
(1) 判断两个对象的hashcode是否相等
如果不相等,认为两个对象也不相等 end
如果相等,转入2
(2) 判断两个对象的equals运算是否相等
如果不相等,认为两个对象也不相等
如果相等,认为两个对象相等
(equals())是判断两个对象是否相等的关键
4.Cat测试辅助类
package _1;
public class Cat {
private String name;
private int age;
private int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Cat [name=" + name + ", age=" + age + ", id=" + id + "]";
}
public Cat(String name, int age, int id) {
super();
this.name = name;
this.age = age;
this.id = id;
}
public Cat() {
super();
}
@Override
public int hashCode() {
final int prime = 31;//系数
int result = 1;
result = prime * result + age;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Cat other = (Cat) obj;
if (age != other.age)
return false;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
5.Cat外部比较器
package _1;
import java.util.Comparator;
public class CatComparator implements Comparator<Cat>{
@Override
public int compare(Cat o1, Cat o2) {
return o1.getAge()-o2.getAge();
}
}
6. Stream类
package _1;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
* Stream接口: 不是存储的数据结构,数据源可以是集合,为了函数式编程创建的,
* 惰性执行: 要用的时候才执行,数据只能被消费一次
*
* 两种类型的操作方法:
* 1 .中间操作(会生成一个Stream)
*
* 2 .结束操作(执行计算操作)
*
* @作者 feng
* @创建时期: 2019年6月10日
* @描述:
*/
public class StreamDemo {
public static void main(String[] args) {
//foreach方法
Stream<String> st = Stream.of("good","good","study","day","day","up");
//st.forEach((str)->System.out.println(str));
//st.forEach(System.out::print);
//filter
//st.filter((s)->s.length()>3).forEach(System.out::println);
//distinst(去除重复的元素)
//st.distinct().forEach(s->System.out.println(s));
//map
//st.map((s)->s.toUpperCase()).forEach(s->System.out.println(s));
//flatMap
Stream<List<Integer>> ss = Stream.of(Arrays.asList(1,2,3),Arrays.asList(4,5,6));
ss.flatMap(list->list.stream()).forEach(System.out::println);
}
}
