集合:装东西的容器;
框架:为了打到某一目的或者实现某个功能,而预先设计好的一系列具有继承或实现关系的类与接口;
Collection接口,常用的集合或是他的直接实现类,或是有间接关系;
三种常用集合:
一.List
特点:a.线性,就是有序的意思,有下标,元素放入集合的顺序就是他存放元素的顺序;
b.可以放入重复元素;
1.ArrayList
ArrayList在内存中依然是连续内存地址,这样做的优点是:查找元素效率高;往末尾添加元素效率高;
List的另一个子类Vector的元素存放方式与ArrayList一样,所以常把他们拿来比较,ArrayList是线程不安全的但是效率高;Vector是线程安全的但是效率低.
常用操作:
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList array = new ArrayList();
//增
array.add(1000);
array.add("hello");
array.add("world");
array.add(new Object());
//获取集合中元素的数量
int num = array.size();
//删
array.remove(1);
//查
Object obj = array.get(2);
//改
array.set(1, "helloworld");
}
2.LinkedList
LinkedList在方法与效果上与ArrayList相同,不同的是元素的储存方式.LinkedList在内存是链式存储元素,集合的引用指向第一个元素,每个元素都有前后两个引用,前引用指向上一个元素,后引用指向下一个元素,第一个元素的前引用为null,最后一个的后引用为null;缺点是,在查找时,必须按顺序一个个的去找;优点是:内存利用率高,向中间添加数据方便.
二.Set
特点:放入的元素无序不重复;
常用的Set是HashSet,他通过两个方法判断放入元素是否重复:1.两个对象的equals返回true表示内容相同;
2.两个对象的HashCode一致为相同;
必须两个都不相同才能放入集合.
常用方法:
public static void main(String[] args) {
HashSet hs = new HashSet();
//增
hs.add(new ArrayList());
hs.add("hello");
//查看集合中元素个数
int num = hs.size();
//删
hs.remove(1);
}
由于是无序存放所以没有下标的说法,没办法操作其中某个元素
三.Map
特点:元素以键值对的形式存入集合;一个键对应一个值;键和值都可以是任意自定义类型;每个键都是唯一的不能重复,值可以有重复.
1.常用的Map是HashMap,他判断键是否相等的方式与HashSet一样
常用方法:
// TODO Auto-generated method stub
/*
* Map集合--映射--元素是以键值对的方式，成对表示的。
* 键不能重复，但是值可以重复
* 键与值都可以是任意数据类型
*
*/
HashMap<Integer, Student> map = new HashMap<Integer, Student>();
//增
map.put(12901, new Student(12901,"zhang3",23));
map.put(12902, new Student(12902,"li4",21));
map.put(12903, new Student(12903,"wang5",24));
//删
map.remove(12902);
//查
Student stu = map.get(12901);
System.out.println(stu);
//改
map.put(12901, new Student(12901,"zhang3",32));
System.out.println(map.size());
//得到map中所有的key
Set<Integer> keySet = map.keySet();
for(Integer key : keySet){
System.out.println(key);
}
//得到map中所有的值
Collection<Student> values = map.values();
for(Student tmpStu : values){
System.out.println(tmpStu);
}
//是否包含某个键
System.out.println(map.containsKey(12904));
//是否包含某个值
System.out.println(map.containsValue(new Student(12901,"zhang3",32)));
HashMap与HashTable的区别:a.HashMap不允许使用null做键,线程不安全;
b.HashTable允许其中一个键是null,线程安全;
2.Properties-一个特殊的Map
特点:a.是属于Map的集合类
b.可以直接操作文件-属性文件(Properties文件)一种专属的文本文件.
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* Properties---属于Map分支的一种集合类;
* 可以操作一种专属格式的文本文件(属性文件，properties文件)
*/
Properties props = new Properties();
//增
// props.setProperty("J120", "J120-123456-10000.0");
// props.setProperty("J121", "J121-123456-11000.0");
// props.setProperty("J122", "J122-123456-12000.0");
//取
// String value = props.getProperty("J121");
//
// //改
// props.setProperty("J121", "J121-123456-11200.0");
//
// //删除
// props.remove("J121");
//
// //同样拥有Map的其他常用方法
// props.containsKey("J121");
// Set<Object> allKey = props.keySet();
// Collection<Object> allValues = props.values();
// for(Object key : allKey){
// String strKey = (String)key;
// }
//写文件---不能单独写入某一个键值对，只能全部写入
//store方法两个参数：1、文件输出流，参数是文件的名字和位置；2、注释，可以不写那就传入null或空串
// try {
// props.store(new FileOutputStream("properties/user.data"), null);
// } catch (FileNotFoundException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
//读文件
try {
props.load(new FileInputStream("properties/user.data"));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Collection allValues = props.values();
for(Object values : allValues){
String strValue = (String)values;
System.out.println(strValue);
}
}
四.集合工具
1.遍历:a.for-each循环
// TODO Auto-generated method stub
/*
* for-each循环专用（只能用作）对集合进行遍历(所谓遍历--指代把集合中的每个元素取出来，操作一次。);
* 支持数组、List、Set
*/
int[] array1 = new int[]{1,3,5,7,9};
// for(int i = 0; i < array1.length; i++){
// System.out.println(array1[i]);
// }
// for(int tmp : array1){
// System.out.println(tmp);
// }
ArrayList<String> lst = new ArrayList<String>();
// lst.add("hello");
// lst.add("world");
// lst.add("hell");
//
// for(String str : lst){
// System.out.println(str);
// }
HashSet<Integer> set = new HashSet<Integer>();
set.add(100);
set.add(120);
set.add(102);
set.add(200);
set.add(122);
for(int in : set){
System.out.println(in);
}
b.迭代器(Iterator)
支持遍历的集合:a.数组支持普通for循环,for-each循环;
b.List支持普通for循环,for-each循环,迭代器;
c.Set支持for-each循环,迭代器;
2.集合工具类:Collections类,Arrays类
public static void main(String[] args) {
// TODO Auto-generated method stub
// 1、addAll---一次往集合中放入多个元素
ArrayList<String> lst1 = new ArrayList<String>();
lst1.add("J129");
lst1.add("J120");
lst1.add("J121");
ArrayList<String> lst2 = new ArrayList<String>();
lst2.add("J124");
lst2.add("J127");
lst2.add("J128");
Collections.addAll(lst2, lst1.get(0),lst1.get(1),lst1.get(2),"hello","world");
//max\min---得到集合中最大的元素和最小的元素
String max = Collections.max(lst1);
String min = Collections.min(lst2);
System.out.println(max);
System.out.println(min);
//排序方法只支持List
//reverse---把一个集合倒序排列，也称之为反转
System.out.println("反转前=====================");
for(String str : lst2){
System.out.println(str);
}
Collections.reverse(lst2);
System.out.println("反转后=====================");
for(String str : lst2){
System.out.println(str);
}
//sort---把集合排序
Collections.sort(lst2);
System.out.println("排序后=====================");
for(String str : lst2){
System.out.println(str);
}
//shuffle---随机混排
Collections.shuffle(lst2);
System.out.println("排序后=====================");
for(String str : lst2){
System.out.println(str);
}
}
五.补充知识点:
1.JDK1.5以后数组作为方法形参的新语法
public void test(){
int[] array = new int[5];
array[0] = 1;
testArray(array);
testArray(1,2,3,4,5,6,7,8,9);
}
//JDK1.5之后用数组做参数的新语法
public void testArray(int... array){
System.out.println(array[0]);
System.out.println(array.length);
}
2.比较器
a.内部比较器-Compareable接口
参与比较的类实现Compareable接口,重写比较方法,传入一个同类型对象,自定义当前对象与传入对象比较内容,得到当前对象与传入对象的位置差,为正则表示当前对象排在传入对象之后,为负则表示当前对象排在传入对象之前.
b.外部比较器-Comparator接口
需要新建一个专门用于比较的类实现Comparator接口,传入2个对象,自定义前对象与后对象比较内容,得到前对象与后对象的位置差,为正则表示前对象排在后对象之后,为负则表示前对象排在后对象之前;
在外部比较器不参与时,元素比较使用内部比较器;当外部比较器参与比较则内部比较器失效.