集合是什么?简单的说就是一种容器,用来装载各种封装后的数据,数组也能装载数据,他和集合有什么区别呢?简单的说,数组是固定的,而集合却是可以随时根据需要增加,删除,改变数据。
集合框架 看图
这是集合里面包含的接口和实现类,我可能知道不是那么多,只能将我学了的记下来
-List接口:存储有序的,可以重复的元素.—相当于“动态”数组
常用方法 :删除remove(int index) 修改set(int index,Object obj) 获取get(int index)插入add(int index,Object obj)
主要实现类:-ArrayList(主要的实现类)
-LinkedList(更适用于频繁的插入、删除操作)
package collectior;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
/**此乃容器也,第一次接触容器,容器一共有collectior(List、set(Hasset)),map(HasMap)这么多接口
* ArrayList:底层实现是数组,线程不安全,效率高。所以,查询快,修改,插入,删除慢。
* LinkedList:底层实现是链表,线程不安全,效率高。所以,查询慢。修改,插入,删除快。
* List与顺序有关,而且可以重复
* set与顺序无关且不可以重复
*/
public class Test01 {
public static void main(String[] args) {
List list=new ArrayList();//父类指向子类的引用
List list0=new LinkedList();//父类指向子类的引用 多态无时不在,面向接口编程
list0.add("imiao");//向list0中添加一个字符串
list0.add(new dog());//向list0中添加一个对象
list0.remove(0);//删除第0个元素
for(int i=0;i<list0.size();i++){
System.out.println(list0.get(i));
}
list.add("aaa");
list.add(new Date());
list.add(new dog());
list.add(1234);//包装类的:自动装箱
System.out.println(list.size());
System.out.println(list.isEmpty());
// list.remove("aaa"); //hasshoode和equals
//System.out.println(list.size());
List list2=new ArrayList();//父类指向子类的引用
list2.add("bbb");
list2.add("ccc");
list.add(list2);
System.out.println(list.size());
//跟顺序有关的操作
String str=(String )list.get(0);
System.out.println(str);
list.set(1, "ababab");
list.remove(0);
}
}
class dog{
public dog() {
System.out.println("this is dog");
}
}
显示结果
this is dog
collectior.dog@77f2fbff
this is dog
4
false
5
aaa
Set接口:存储无序的,不可重复的元素。—相当于高中的“集合”概念
添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。要求重写equals() 和 hashCode()方法保持一致。
1.无序性:无序性不等于随机性。真正的无序性,指的是元素在底层存储的位置是无序的。
2.不可重复性:当向Set中添加进相同的元素的时候,后面的这个不能添加进去。
HashSet(主要的实现类)
LinkedHashSet(是HashSet的子类,当我们遍历集合元素时,是按照添加进去的顺序实现的;频繁的遍历,较少的添加、插入操作建议选择他)
TreeSet(可以按照添加进集合中的元素的指定属性进行排序,默认升序)
添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。要求重写equals() 和 hashCode()方法保持一致
两个对象equals相等,那么它的hashcode相等
两个对象equals不相等,那么它的hashcode并不要求它不相等,但一般建议不相等
hashcode相等不代表两个对象相等(采用equals比较)
package collectior;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class TestSet {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "小明";
p1.age = 8;
Person p2 = new Person();
p2.name = "小红";
p2.age = 5;
Person p3 = new Person();
p3.name = "小红";
p3.age = 10;
Set set = new HashSet();
set.add(p1);
set.add(p2);
set.add(p3);
for (Iterator iter=set.iterator(); iter.hasNext();) {
Person p = (Person)iter.next();
System.out.println("name=" + p.name + ", age=" + p.age);
}
System.out.println("p1.hashCode=" + p1.hashCode());
System.out.println("p2.hashCode=" + p2.hashCode());
System.out.println("p3.hashCode=" + p3.hashCode());
Set set0 =new HashSet();
set0.add("aaa");
set0.add("ddd");
set0.add(set);
set0.add(new String ("aaa"));
System.out.println(set0.size());//2,表明是不可以插入重复的数据的
for (Iterator iter=set0.iterator(); iter.hasNext();) {
System.out.println(iter.next());
}
/**
* 3
[(this Collection), aaa, ddd]
aaa
ddds
*
*/
//表明输出结果是无序的
//set.remove("aaa");
}
}
显示结果:
name=小明, age=8
name=小红, age=5
p1.hashCode=756703
p2.hashCode=762995
p3.hashCode=762995
3
[collectior.Person@b8bdf, collectior.Person@ba473]
aaa
ddd
再来看一个treeSet的例子
package collectior;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class TesttreeSet {
public static void main(String[] args) {
Set set0 = new TreeSet();
set0.add(1);
set0.add(8);
set0.add(5);
set0.add(3);
for (Iterator set=set0.iterator(); set.hasNext();) {
int int1 = (int)set.next();//强制类型转换成int
System.out.print(int1+"\t");
}
}
}
显示结果
1 3 5 8 按升序排序输出
继续排序 实现Comparable接口
package collectior;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class TestSet {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "小明";
p1.age = 8;
Person p2 = new Person();
p2.name = "小红";
p2.age = 5;
Set set = new TreeSet();
set.add(p1);
set.add(p2);
for (Iterator iter=set.iterator(); iter.hasNext();) {
Person p = (Person)iter.next();
System.out.println("name=" + p.name + ", age=" + p.age);
}
}
}
package collectior;
public class Person implements Comparable {//实现Comparable接口
String name;
int age;
//重写hashCode()
public int hashCode() {
return (name==null)?0:name.hashCode();
}
//重写equals
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Person) {
Person p = (Person)obj;
return this.name.equals(p.name);
}
return false;
}
public int compareTo(Object o) {//重写copareTo()方法
if (o instanceof Person) {
Person p = (Person)o;
//降序
return ( p.age-this.age);
}
throw new IllegalArgumentException("非法参数,o=" + o);
}
}
显示结果:
name=小明, age=8
name=小红, age=5
继续排序 实现Comparator接口
package collectior;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class TestSet {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "小明";
p1.age = 8;
Person p2 = new Person();
p2.name = "小红";
p2.age = 5;
//内部类实现Coparator方法,所谓内部类就是在new的同时把类给直接写出来了 不需类名,却可以访问外部类的属性和方法
Set set = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (!(o1 instanceof Person)) {//instanceof的意思是检查传入的对象与原对象是否一致
throw new IllegalArgumentException("非法参数,o1=" + o1);
}
if (!(o2 instanceof Person)) {
throw new IllegalArgumentException("非法参数,o2=" + o2);
}
Person p1 = (Person)o1;
Person p2 = (Person)o2;
return p2.age - p1.age;
}
});
set.add(p1);
set.add(p2);
for (Iterator iter=set.iterator(); iter.hasNext();) {
Person p = (Person)iter.next();
System.out.println("name=" + p.name + ", age=" + p.age);
}
}
}
显示结果:
name=小明, age=8
name=小红, age=5
一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的,这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现,将算法和数据分离
Map接口:存储“键-值”对的数据 —-相当于高中的
key是不可重复的,使用Set存放。value可以重复的,使用Collection来存放。一个key-value对构成一个entry(Map.Entry),entry使用Set来存放
常用方法:添加put(Object key,Object value)
删除remove(Object key)
获取get(Object key) size() / keySet() values() entrySet()
HashMap:主要的实现类,可以添加null键,null值
LinkedHashMap:是HashMap的子类,可以按照添加进Map的顺序实现遍历
TreeMap:需要按照key所在类的指定属性进行排序。要求key是同一个类的对象。对key考虑使用自然排序 或 定制排序
我不想举例了。。。。。。
Iterator接口:用来遍历集合Collection元素,foreach就是Iterator加入泛型后的产品
来了解一下这个类
Collections工具类:操作Collection及Map的工具类,大部分为static的方法。
泛型 :这个就是C++中的函数模板,很相似,后面会夹带出现,但就不单独作为一个点来细细记了
这篇好像写得有点多了哦 ,我会加油的,博客的质量也会越来越好的