java27:集合框架

标签：object   java   equals   接口   元素   

数组有弊端

    数组需要定义长度，在不知道数据量的前提下使用时比较麻烦的，要频繁的对数组进行扩容

    当向数组中插入元素时，其他元素都要向后移动，这也为我们使用数组提供了额外的维护数组的代码量

所以就有另一种 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);
		}
	}
}

本文出自 “浪漫的偷笑” 博客，转载请与作者联系！

java27:集合框架

标签：object   java   equals   接口   元素   

原文地址：http://lmdtx.blog.51cto.com/6942028/1739251