在存储的时候通常考虑的对象是数组或者集合,但在java中数组存在一些弊端,一旦创建,其长度不可变,在数组中真实存储的对象个数是个未知数.
一 : Collection接口
其子接口有List 与 Set.
List接口其主要面向存储有序的,可以重复的元素
List接口的主要实现类是 ArrayList与linkedList
ArrayList是List接口的主要实现类,LinkedList面向比较频繁的操作如删除操作,因为其实现方式主要是链表.
Set接口主要面向的是存储无序的,不可重复的元素
Set接口的主要实现类为HashSet,LinkedHashSet,TreeSet,Hashtable(子类 : Properties)
Collection接口提供一些通用的方法,下面一一介绍一下
-
Size();
返回集合中元素的个数
Collection coll = new ArrayList();
System.out.println(coll.size());
-
add(Oject obj);
向集合中添加元素
Collection coll = new ArrayList();
coll.add(123);//123 自动转换成包装类
coll.add("AA");
coll.add(new Date());
coll.add("BB");
System.out.println(coll);
打印结果
[123, AA, Tue Jul 17 16:59:47 CST 2018, BB]
-
addAll
向集合中添加另一个集合
Collection coll = new ArrayList();
coll.add("AA");
Collection coll1 = Arrays.asList(1,2,3);
coll.addAll(coll1);
-
isEmpty()
判断集合是否为空
Collection coll = new ArrayList();
System.out.println(coll.isEmpty());
-
clear() 清空集合元素
Collection coll = new ArrayList();
coll.add("AA");
coll.clear();
-
contains(Object obj)
判断集合是否包含指定的obj元素,如果包含返回true,否则返回false.
如果存入集合中的元素是自定义类的对象,自定义类要重写equals()方法,添加进List集合的元素(或者对象)所在类一定要重写equals()方法
Collection coll = new ArrayList();
coll.add(123);//123 自动转换成包装类
coll.add("AA");
boolean b1 = coll.contains(123);
判断是否包含自定义对象
Person p = new Person();
boolean b2 = coll.contains(p);
自定义类Person类要重写 equals()方法
class Person{
//属性部分
private String name;
private int age;
public Person() {
super();
}
//构造方法
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
//set/get方法
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;
}
//重写toString
@Override
public String toString() {
return "person [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
//重写equals方法
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
-
containsAll(coll)
判断是否包含所有元素
Collection coll1 = new ArrayList();
coll1.add(123);
coll1.add("AA");
boolean b3 = coll.containsAll(coll1);
-
retainAll(coll)
求当前集合与参数集合的共有元素,返回给当前集合
Collection coll = new ArrayList();
coll.add(123);//123 自动转换成包装类
coll.add("AA");
Collection coll1 = new ArrayList();
coll1.add(234);
coll1.add("AA");
coll.retainAll(coll1);
System.out.println(coll);
-
remove(Object obj)
删除集合中obj元素,若删除成功返回True,否则返回false
Collection coll = new ArrayList();
coll.add(123);//123 自动转换成包装类
coll.add("AA");
boolean b = coll.remove("123");
System.out.println(b);
-
removeAll(Collection coll)
从当前集合中删除包含coll中元素
coll.removeAll(coll1);
System.out.println(coll);
-
equals(Object obj)
判断集合中的所有元素是否完全相同
Collection coll = new ArrayList();
coll.add(123);//123 自动转换成包装类
coll.add("AA");
Collection coll1 = new ArrayList();
coll1.add(234);
coll1.add("AA");
System.out.println(coll1.equals(coll2));
-
hashCode();
返回集合哈希值
Collection coll1 = new ArrayList();
coll1.add(234);
System.out.println(coll1.hashCode());
-
toArray()
将集合转化成数组
Collection coll = new ArrayList();
coll.add(123);//123 自动转换成包装类
coll.add("AA");
Object[] obj = coll.toArray();
for (int i = 0; i < obj.length; i++) {
System.out.println(obj[i]);
}
-
iterator()
返回一个Iterator接口实现类的对象.实现集合的遍历
Iterator iterator = coll.iterator();
System.out.println(iterator.next());
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
list接口
ArrayList
list的主要实现类
-
在指定的索引位置index添加元素
List list = new ArrayList();
list.add(123);
list.add(456);
//在指定的索引位置index添加元素
list.add(0,55);
-
获取指定索引的元素
List list = new ArrayList();
list.add(123);
list.add(456);
Object obj = list.get(1);
-
删除指定索引位置的元素
List list = new ArrayList();
list.add(123);
list.add(456);
list.remove(0);
-
设置指定索引位置的元素
List list = new ArrayList();
list.add(123);
list.add(456);
list.set(0, 111);
-
返回obj在集合中首次出现的位置 没有的话返回-1
List list = new ArrayList();
list.add(123);
list.add(456);
list.indexOf(123);
-
返回obj在集合中最后一次出现的位置 没有的话返回-1
List list = new ArrayList();
list.add(123);
list.add(456);
list.lastIndexOf(456);
-
返回从fromIndex 到toIndex结束的一个子list
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(new String("aa"));
list.add(new String("bb"));
list.subList(0, 3);//不含末尾,包含头 左闭右开
LinkedList
主要使用链表实现,适用于频繁的操作,其操作放与ArrayList相同
LinkedList list = new LinkedList();
list.add(123);
list.add(456);
list.add("雪芙");
list.add("百百");
list.set(1, 111);
list.remove(0);
list.get(0);
/增强for循环/
for(Object o:list) {
System.out.println(o);
}
set接口
Set接口,存储无序的,不可重复的元素,Set中常用的方法都是Collection下定义的.
Set存储的元素是无序的,不可重复的!
1.无序性,无序性!= 随机性 ,真正的无序性指的的是元素在底层存储的位置是无序的
2.不可重复性,当向Set中添加进相同的元素的时候,后面的这个不能添加进去.
3.要求添加进Set的元素所在的类,一定要重写equals() 和 hasCode()方法,进而保证Set中元素的不可重复性!
Set中的元素的存储方式: 使用了哈希算法,当向Set中添加对象时,首先调用此对象所在类的hashCode()方法,计算此对象的哈希值,此哈希值决定了此对象在Set中的存储位置,若此位置之前没有对象存储,则这个对象直接存到此位置.若此位置已经有对象存储,再通过equals()比较这两个对象是否相同,如果相同,后一个对象就不能再添加进来
要求:hashCode()方法要与equals方法一致
子接口
- HashSet(主要实现类)
- LinkedHashSet
- TreeSet
-
HashSet
public void testHashSet() {
Set set = new HashSet();
set.add(123);
set.add(456);
set.add("xf");
set.add("xf");
set.add(null);
Personzz p1 = new Personzz("雪芙", 23);
Personzz p2 = new Personzz("雨辰", 22);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
set.add(p1);
set.add(p2);
System.out.println(set.size());
System.out.println(set);
}
class Personzz {
String name;
Integer age;
public Personzz(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {// return age.hashcode()+name.hashcode(); 没有自带的健壮性好
final int prime = 31;// 质数
int result = 1;
result = prime * result + age;
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;
Personzz other = (Personzz) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
打印结果
1232761
1236019
6
[null, com.TianTianBaby.java.Personzz@12dc33, 456, 123, com.TianTianBaby.java.Personzz@12cf79, xf]
-
LinkedHashSet
使用链表维护了一个添加进集合的顺序,导致我们遍历LinkedHashSet集合元素时,是按照添加进去的顺序遍历的.
LinkedHashSet插入性能略低于HashSet因为链表要先破坏之前的连接,但在迭代访问Set里的全部元素时有很好的性能.
public void tesLinkedHashSet() {
Set set = new LinkedHashSet();
set.add(123);
set.add(456);
set.add("xf");
set.add("xf");
set.add(null);
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
打印结果
123
456
xf
null
-
TreeSet
①.向TreeSet中添加的元素必须是同一个类型的
②.可以按照添加进集合中的元素的指定的顺序遍历,像String,包装类等默认按照从小到大的顺序遍历
public void testTreeSet1() {
Set set = new TreeSet();
// 当Person类没有实现Compareable接口时,当向TreeSet中添加Peronzz对象时,报
// ClassCastException
set.add(new Personzz("岑", 22));
set.add(new Personzz("岑1", 23));
set.add(new Personzz("岑2", 24));
set.add(new Personzz("岑3", 24));
for (Object str : set) {
System.out.println(str);
}
}
打印结果
com.TianTianBaby.java.Personzz@62fc
com.TianTianBaby.java.Personzz@b3c4a
com.TianTianBaby.java.Personzz@b3c6a
com.TianTianBaby.java.Personzz@b3c6b
③.自然排序,当向TreeSet中添加自定义类的对象时,有两种排序方法
自然排序 :要求自定义类实现java.lang.Comparable接口并且重写Compareable(Object obj)在此方法中,指明按照自定义类的哪个属性进行排序.
class Personzz implements Comparable {
String name;
Integer age;
public Personzz(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Personzz(String name) {
super();
this.name = name;
}
@Override
public int hashCode() {// return age.hashcode()+name.hashcode(); 没有自带的健壮性好
final int prime = 31;// 质数
int result = 1;
result = prime * result + age;
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;
Personzz other = (Personzz) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
// 当向TreeSet中添加Person类的对象时,依据此方法,确定按照那个属性排列
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
if (o instanceof Personzz) {
Personzz p = (Personzz) o;
// return this.name.compareTo(p.name) ;
// return this.age.compareTo(p.age);
// return -this.age.compareTo(p.age);//倒序
int i = this.age.compareTo(p.age);
if (i == 0) {
return this.name.compareTo(p.name);
} else {
return i;
}
}
return 0;
}
}
总结 : 向TreeSet中添加元素时,首先按照CompareTo()方法进行比较,一旦返回0,虽然仅是两个对象的属性值相同,但程序会认为这两个对象是相同的,进而后一个对象不能添加进来,所以CompareTo()与hasCode()以equals()三者保持一致!
④.定制排序
无法操作类,Compare()与hashCode()以及equals()三者保持一致
public void testTreeSet2() {
// 1.创建一个实现了Comparater接口的类对象
Comparator com = new Comparator() {
// 向TreeSet中添加Customer类的对象,在此compare()方法中,指明的是按照customer的哪个属性排序的
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
//正序
return 1;
}
return 0;
}
};
// 2.将此对象作为形参传递给TreeSet的构造器中
TreeSet set = new TreeSet(com);
// 3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象
set.add(new Customer("AA", 1003));
set.add(new Customer("BB", 1004));
set.add(new Customer("CC", 1005));
set.add(new Customer("DD", 1006));
set.add(new Customer("EE", 1006));
for (Object str : set) {
Customer cus = (Customer)str;
System.out.println(cus.getName());
}
}
打印结果
AA
BB
CC
DD
EE
Customer 类
public class Customer {
private String name;
private Integer id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Customer(String name, Integer id) {
super();
this.name = name;
this.id = id;
}
}
匿名方法
public void testTreeSet3() {
// 1.创建一个实现了Comparater接口的类对象
// 2.将此对象作为形参传递给TreeSet的构造器中
TreeSet set = new TreeSet(new Comparator() {
// 向TreeSet中添加Customer类的对象,在此compare()方法中,指明的是按照customer的哪个属性排序的
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
return 1;
}
return 0;
}
});
// 3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象
set.add(new Customer("AA", 1003));
set.add(new Customer("BB", 1004));
set.add(new Customer("CC", 1005));
set.add(new Customer("DD", 1006));
set.add(new Customer("EE", 1006));
for (Object str : set) {
System.out.println(str);
}
}
二 : MAP接口
-
HashMap
key是用set来存放的,不可重复,value是用Collection来存放的,可重复 一个key-value是一个Entry,所有的Entry是用Set存放的,也是不可重复的.
向HashMap中添加元素时,会调用key所在类的equals()方法,判断两个key是否相同,若相同则只能添加进后添加的那个元素.
public void test1() {
Map map = new HashMap();
//向Map中添加一个元素
map.put("雪芙", 35);
map.put("雨辰", 32);
map.put("代劲", 38);
map.put(null, null);
map.put("雨辰", 35);
map.put(new Personzz("馨日",23), 30);
map.put(new Personzz("馨月",23), 34);
System.out.println(map.size());
System.out.println(map);
//按照指定的key删除key-value对
map.remove("代劲");
//putAll 将一个新的Map中所有元素添加进来
//clear清空
//get获取指定Key的Value值若无此Key 返回null
map.get("雨辰");
}
Map的遍历方法
public void test2() {
Map map = new HashMap();
//向Map中添加一个元素
map.put("雪芙", 35);
map.put("雨辰", 32);
map.put("代劲", 38);
map.put(null, null);
}
LinkedHashMap 与 HashMap操作一样
public void test3() {
Map map = new LinkedHashMap();
//向Map中添加一个元素
map.put("雪芙", 35);
map.put("雨辰", 32);
map.put("代劲", 38);
map.put(null, null);
map.put(new Personzz("馨日",23), 30);
Set set1 = map.keySet();
for(Object obj:set1) {
System.out.println(obj+"--->>>"+map.get(obj));
}
}
- 遍历key集
Set set = map.keySet();
for(Object obj : set) {
System.out.println(obj);
}
打印结果
null
代劲
雨辰
雪芙
- 遍历value集
Collection values = map.values();
Iterator i = values.iterator();
while (i.hasNext()) {
System.out.println(i.next());
}
打印结果
null
38
32
35
- 遍历Key-value对
方式一
Set set1 = map.keySet();
for(Object obj:set1) {
System.out.println(obj+"--->>>"+map.get(obj));
}
打印
null--->>>null
代劲--->>>38
雨辰--->>>32
雪芙--->>>35
方式二
Set set2 = map.entrySet();
for(Object obj:set2) {
Map.Entry entry = (Map.Entry)obj;
System.out.println(entry.getKey()+"----->"+entry.getValue());
System.out.println(entry);
}
打印
null----->null
null=null
代劲----->38
代劲=38
雨辰----->32
雨辰=32
雪芙----->35
雪芙=35
TreeMap 自然排序 与TreeSet方法相同
public void test4() {
Map map = new TreeMap();
//向Map中添加一个元素
map.put(new Personzz("aa",23), 30);
map.put(new Personzz("bb",22), 30);
map.put(new Personzz("cc",21), 30);
map.put(new Personzz("dd",21), 30);
Set set1 = map.keySet();
for(Object obj:set1) {
System.out.println(obj+"--->>>"+map.get(obj));
}
}
TreeMap 定制排序
public void test5() {
Comparator com = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
return 1;
}
return 0;
}
};
TreeMap map = new TreeMap(com);
map.put(new Customer("aa" , 1001), 80);
map.put(new Customer("bb", 1002), 81);
map.put(new Customer("cc", 1003), 82);
map.put(new Customer("dd", 1004), 83);
Set set1 = map.keySet();
for(Object obj:set1) {
System.out.println(obj+"--->>>"+map.get(obj));
}
}
使用properties处理属性文件
public void test6() throws FileNotFoundException, IOException {
Properties pros = new Properties();
pros.load(new FileInputStream(new File("jdbc.properties")));
String str = pros.getProperty("user");
String password = pros.getProperty("password");
System.out.println(str);
System.out.println(password);
}
Enumeration接口
Enumeration 接口是Iterator迭代器的古老版本
public class TestEnumeration {
public static void main(String[] args) {
Enumeration enu = new StringTokenizer("ab-c*-df-g","-");
while(enu.hasMoreElements()) {
System.out.println(enu.nextElement());
}
}
}
打印
ab
c*
df
g
四 : Collections
操作Collection以及Map的工具类
使用方法
public void testCollections1() {
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(789);
list.add(15);
System.out.println(list);
//反转
Collections.reverse(list);
System.out.println(list);
//随机排序
Collections.shuffle(list);
//根据元素的自然排序指定List集合元素按升序排序
Collections.sort(list);
//根据指定的Compartor产生的顺序对List集合元素进行排序
// Collections.sort(list, c);
//swap(List,int i,int j)将指定List集合中的i处元素和j处元素进行交换
Collections.swap(list, 0, 3);
}
public void testCollections2() {
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(789);
list.add(15);
Collections.max(list);
Collections.min(list);
//返回指定集合中指定元素的出现次数
int count = Collections.frequency(list, 15);
System.out.println(count);
//实现List的复制
//void copy(List dest,list src)将src中的内容复制到desc中
// List list1 = new ArrayList();//错误的实现方式
List list1 = Arrays.asList(new Object[list.size()]);
Collections.copy(list1, list);
System.out.println(list1);
//boolean replaceAll(List list,object oldVal ,object newVal)
//使用新值替换List旧值
//线程安全的 该方法可使将指定集合包装成线程同步的集合,从而可以解决多线程并发访问集合时
//的线程安全问题
List list2 = Collections.synchronizedList(list);
System.out.println(list2);
}