java27:集合框架
数组有弊端
数组需要定义长度，在不知道数据量的前提下使用时比较麻烦的，要频繁的对数组进行扩容
当向数组中插入元素时，其他元素都要向后移动，这也为我们使用数组提供了额外的维护数组的代码量
所以就有另一种 java中的集合框架
Collection接口
这个接口定义了集合的相关特征.
这个接口派生了两个子接口
List：可重复集合（同一个元素可以放入若干次）
用一个元素是指的equals 为true的
有序集
Set: 不可重复集合
无序集
方法：
int size() 返回集合中的元素数量里面有多少元素就返回多少
boolean isEmpty() 集合是不是空的没有元素返回true 有元素返回false
boolean contains(Object obj) 集是否包含指定的元素
void clear() 清空集合
boolean add(E e) 向集合中添加元素
boolean remove(E e) 从集合中删除指定元素
boolean addAll(Collection c):将给定集合中的所有元素添加到当前集合（并集）
boolean removeAll(Collection c):删除当前集合（只删除当前的）中与给定集合相同的元素
Iteator iterator() 迭代器 定义了遍历集合的相关方法，不同的集合有不同的迭代器实现
boolean hasNext() 是否还有元素可以获取
Object next() 获取元素
void remove()删除当前迭代出的元素
遍历集合的顺序要：问->取（->删），删除可不做
List 集合的实现类
ArrayList 内部使用数组实现的集合 比较常用 查询速度快
根据数组的实现原理，这个集合更适合查询数据，但是对频繁的增删元素 效率低下
LinkedList 使用链表方式实现的机会 频繁的修改元素
根据链表的实现原理这个集合更适合增删元素，但是对于频繁的查询元素 效率低下
package day27;
import java.util.ArrayList;
import java.util.List;
/**
*ArrayList
*List 的子类实现
*由数组方式实现的可重复的有序集
*/
public class Demo01 {
public static void main(String[] args){
List list = new ArrayList();
list.add("1");//list 是有序的集合 所以add方法是顺序向集合末尾添加元素
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("7");
list.add("8");
System.out.println(list.size());
System.out.println(list.isEmpty());
System.out.println(list);
list.clear();
System.out.println(list.size());
System.out.println(list.isEmpty());
System.out.println(list);
}
}package day27;
import java.util.ArrayList;
import java.util.List;
public class Demo02 {
public static void main(String[] args){
List list1 = new ArrayList();
List list2 = new ArrayList();
List list3 = new ArrayList();
list1.add("1");
list1.add("2");
list1.add("3");
list2.add("4");
list2.add("5");
list3.add("1");
list3.add("2");
//判断元素是否相同，使用的是equals方法
list1.addAll(list2);//将集合2中元素存入集合1
System.out.println(list1);
list1.removeAll(list3);//将集合1中与集合3相同的元素删除
System.out.println(list1);
list1.retainAll(list2);//只保留集合1中与集合2都有的元素 取交集
System.out.println(list1);
}
}增删改查
List接口中定义的方法
get(int index) 获取指定位置的元素 只有List集合具有
set(int index,Object obj)将指定位置上的元素替换为给定元素，返回被替换的元素
add(int index,Object o)重载的方法 在指定位置插入给定的元素，原来的元素顺序向后移动
remove(int index)重载的方法，删除指定位置的元素，返回被删除的元素
indexOf()查找给定元素在集合中第一次出现的位置
lastIndexOf()查找给定元素在集合中最后一次出现的位置
package day27;
import java.util.ArrayList;
import java.util.List;
public class Demo03 {
public static void main(String[] args){
List list = new ArrayList();
list.add("1");
list.add("1");
list.add("2");
list.add("3");//增
list.add("44");
list.remove(2);//删下标是2的
list.add("3");
list.add(1,11);//插入一个新元素
list.remove("44");//删除一个指定的元素
System.out.println("第一次输出集合："+list);
//获取回来时时以Object获取的，需要造型
String element = (String)list.get(2);//有下标越界问题从0开始
System.out.println("输出下标为2的元素："+element);
Object old =list.set(1,"22");//改
System.out.println("输出将第二个元素修改后的结果:"+list);
System.out.println("输出修改时候的返回值:"+old);
int index = list.indexOf("3");//第一次出现的位置
System.out.println("元素第一次出现的位置"+index);
int lastindex = list.lastIndexOf("1");
System.out.println("元素最后一次出现的位置"+lastindex);
for(int i = 0 ; i<list.size();i++){//集合的迭代输出
System.out.print(list.get(i)+",");//查
}
System.out.println();
for(int i = 0 ; i<list.size();i++){
System.out.println(list.get(i));
}
//数组的
int[] arr = new int[5];
for(int i = 0; i<arr.length;i++){
arr[i]=i+100;
}
for(int a:arr){
System.out.println(a);
}
}
}Collection定义的方法：
toArray()
package day27;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Demo04 {
public static void main(String[] args){
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
Object[] array = list.toArray();
//参数给定的就是具体要转换的数组的实例，不需要长度 减少浪费空间
//返回时要造型
//要转换的数组类型要和集合中存放的类型一致
// **********
//所有数组都是Array的类型
String[] strArray = (String[])list.toArray(new String[0]);
System.out.println(Arrays.toString(strArray));
List list2 = new ArrayList();
list2.add(1);
list2.add(2);
list2.add(3);
Integer[] intArray = (Integer[])list2.toArray(new Integer[0]);
System.out.println(Arrays.toString(intArray));
}
}package day27;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class Demo05 {
public static void main(String[] args){
List list = new LinkedList();
list.add("1");
list.add("#");
list.add("2");
list.add("#");
list.add("3");
list.add("#");
list.add("4");
list.add("#");
list.add("5");
Iterator it = list.iterator();
while(it.hasNext()){
String element = (String)it.next();
if("#".equals(element)){
it.remove();//通过迭代器删除刚刚被迭代出来的元素
}
System.out.println(element);
}
System.out.println(list);
}
}泛型
1.5 之后的特性
泛型的本质就是参数化类型，在使用某个类时为方法，属性等指定类型。
允许多个 泛型 使用 , 隔开
更加灵活
动态给类型
尽量使用有意义的名字
泛型不能参与运算
定义后不指定类型，就是Object类
java 是强类型语言 不像python
so 泛型是假的 其实他还是Object 只是java知道他是你指定的类型 会自动的类型转换， 也有可能会有类造型异常的现象(ClassCastException)（自己作孽）
package day27;
public class Demo07<X,Y> {
private X x;
private Y y;
public Demo07(X x,Y y){
this.x = x;
this.y = y;
}
public X getX(){
return x;
}
public Y getY(){
return y;
}
public void setX(X x){
this.x = x;
}
public void setY(Y y){
this.y = y;
}
}package day27;
public class Demo08 {
public static void main(String[] args){
Demo07<Double,String> p = new Demo07<Double,String>(3.14,"3.14");
Demo07<Integer,Integer> p2 = new Demo07<Integer,Integer>(1,1);
Demo07<Integer,String> p3 = new Demo07<Integer,String>(1,"1");
Demo07 p4 = new Demo07(1,2);//定义后不指定类型，就是Object类
p.setX(3.1415);
p2.setX(111);
p3.setY("3.123");
}
}package day27;
//泛型是假的 其实他还是Object 只是java知道他是你指定的类型 会自动的类型转换， 也有可能会有类造型异常的现象(ClassCastException)（自己作孽）
public class Demo09 {
public static void main(String[] ags){
Demo07<Integer,Integer> p = new Demo07<Integer,Integer>(1,1);
p.setX(2);
p.setY(2);
set(p);
int x = p.getX();//Exception in thread "main" java.lang.ClassCastException: java.lang.Double cannot be cast to java.lang.Integer
int y = p.getY();
System.out.println(x+","+y);
}
public static void set(Demo07 p){
p.setX(3.1);
p.setY(3.1);
}
}集合中的泛型
集合中的泛型通常是约束集合中存放元素的类型
package day27;
import java.util.ArrayList;
import java.util.List;
public class Demo10 {
public static void main(String[] args){
List<String> list = new ArrayList<String>();//限制了list 集合中的数据，只能是String类型
list.add("1");//泛型约束了add 方法的参数类型
//list.add(1);
String element = list.get(0);//也约束了get方法的返回值类型
System.out.println(element);
}
} 迭代器也支持泛型，知识需要注意 迭代器的泛型应该与要迭代的集合的泛型保持一致
package day27;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo11 {
public static void main(String[] args){
List<String> list = new ArrayList<String>();//限制了list 集合中的数据，只能是String类型
list.add("一");//泛型约束了add 方法的参数类型
//list.add(1);
list.add("二");
list.add("三");
list.add("四");
String element = list.get(0);//也约束了get方法的返回值类型
System.out.println(element);
System.out.println("--------------------");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String elements = it.next();
System.out.println(elements);
}
}
}转载于:https://blog.51cto.com/lmdtx/1739251