Java高级特性Collection

最新推荐文章于 2018-12-07 09:01:29 发布

zsyht_2712

最新推荐文章于 2018-12-07 09:01:29 发布

阅读量219

点赞数

本文链接：https://blog.csdn.net/zsyht_2712/article/details/78487383

版权

对象数组引出集合

对象数组:可以存储对象的数组

/**
 * 
 */
package org.zst.collection;

/**
 * @author：zsyht
 * @date：2017-11-9上午11:11:07
 */
public class Student {
	private int age;
	private String name;

	public Student() {
		super();
	}
	public Student(String name,int age){
		this.name=name;
	    this.age=age;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

/**
 * 
 */
package org.zst.collection;

/**
 * @author：zsyht
 * @date：2017-11-9上午11:07:33
 */
public class Demo {
	public static void main(String[] args) {
		
		//学生类创建完毕
		//定义一个学生数组:定义数组的格式:数据类型[] 数组名称 = new 数据类型[数组长度] ;
		//定义一个学生数组
		Student[] students = new Student[5] ;
		//创建5个学生对象
		Student s1 = new Student("yyb", 20) ;
		Student s2 = new Student("fyy", 20) ;
		Student s3 = new Student("mmw" ,20) ;
		Student s4 = new Student("lyq" ,20) ;
		Student s5 = new Student("zst" ,19) ;
		//赋值
		students[0] = s1 ;
		students[1] = s2 ;
		students[2] = s3 ;
		students[3] = s4 ;
		students[4] = s5 ;
		
		//遍历学生数组
		for(int x = 0 ; x <students.length ; x ++){
			//System.out.println(students[x]);//此时该语句输出五个地址值
			//通过底层原码重写toString()得到的每个对象的成员变量的信息
			
			Student s = students[x] ;
			System.out.println(s.getName()+","+s.getAge());
		}
	}
}

集合

集合的由来:我们学习java的语言,是一种面向对象语言,面向对象语言对事物的描述是通过对象体现出来的,那么存储很多个学生,就需要使用容器变量进行存储
目前学习过的容器变量：
数组：对于数组来说,数组的长度是固定的,不符合实际需求(长度不可变)

StringBuffer/StringBuilder：StringBuffer来说始终在内存中返回的是字符串类型,也不满足元素类型变化的要求

所以Java就提供了集合!

面试题:
集合和数组的区别?
1)长度的区别:
数组:长度是固定的;
集合:长度是可变的

2)存储数据类型的区别:
数组:可以存储引用类型,可以存储基本数据类型
集合:只能存储引用类型

3)存储元素的区别
数组:在同一个数组中,只能存储同一种数据类型的元素;举例数组:杯子:只能装水
集合:可以存储多种数据类型的元素; 举例:集合:杯子:装水,其他饮料...

集合是可以存储多种类型的元素,但是,需求如果变化,针对集合来说,Java提供了很多集合类,每一种集合类的数据结构不一样,所以,将他们之间的共性内容抽取出来,就行了
一个集合的继承体系图!

数据结构:存储数据的方式

Collection: 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现

Collection的一些功能
添加功能:
boolean add(Object e):给集合中添加指定的元素
boolean addAll(Collection c):添加一个集合中的所有元素

删除功能:
void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)
boolean remove(Object o):删除一个集合中的指定元素
boolean removeAll(Collection c):删除一个集合中的所有元素删除一个算是删除

判断功能:
boolean contains(Object o):判断一个集合中是否包含指定的单个元素
boolean containsAll(Collection c):判断一个集合中是否另一个集合;包含所有元素算是包含
boolean isEmpty():判断集合是否为空,如果为空,则返回true

交集功能:
boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?

获取功能;
int size():获取集合中的元素数
Iterator<E> iterator():迭代器

转换功能:
Object[] toArray():将集合转换成数组

public static void main(String[] args) {
		
		//创建Collection集合对象
		Collection c = new ArrayList() ;
		
		//给集合中添加元素
		c.add("高圆圆") ;//c.add(Object obj)=====>Object obj = new String("高圆圆") ;//向上转型了
		c.add("邓超") ;
		c.add("WE") ;
		c.add("RNG") ;
		
		//集合中有元素了,将集合转换数组
		Object[] objs = c.toArray() ;
		//遍历对象数组
		for(int x = 0 ; x < objs.length ; x ++){
//			System.out.println(objs[x]);
			//需求:获取集合中元素的同时,获取集合中每一个元素的字符串长度
//			System.out.println(objs[x]+"---"+objs[x].length());
			//要获取字符串长度:需要使用length(),该方法属于String类的特有功能
			String s = (String) objs[x] ;//向下转型
			System.out.println(s+"----"+s.length());
		}
	}

面试题:
   数组中有没有length(),String类中有没有length(),集合中有没有length()?
   数组:length属性
String:length()
   集合中:size()

/**
 * 
 */
package org.zst.collection;
import java.util.ArrayList;
import java.util.Collection;

/**
 * @author：zsyht
 * @date：2017-11-9上午11:40:50
 */
public class CollectionDemo {
	public static void main(String[] args) {
		//创建一个Collection集合对象
		//Collection c = new Collection() ;//JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现
		Collection c = new ArrayList() ;
		System.out.println(c);//[]   底层重写了toString()，此时打印的不是地址值而是一个"[]".
		
		//添加功能:
		//给集合中添加指定的元素
		boolean flag = c.add("hello") ;
		/**
		 * 通过查看集合的add()方法,只要给集合中添加元素,永远返回true
		 *  public boolean add(E e) {
		 *  //省略代码
        	return true;
    		}
		 */
		c.add("hello") ;
		c.add("world") ;
		c.add("Java") ;
		
		//void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)
		//c.clear() ;
		
		//boolean remove(Object o):删除一个集合中的指定元素
	    System.out.println("remove:"+c.remove("hello")) ;
		System.out.println("remove:"+c.remove("javaweb")) ;
		
		//boolean contains(Object o):判断一个集合中是否包含指定的单个元素
		System.out.println("contains:"+c.contains("world"));
		System.out.println("contains:"+c.contains("android"));
		
		//boolean isEmpty():判断集合是否为空,如果为空,则返回true
		System.out.println("isEmply:"+c.isEmpty());	
		
		//int size():获取集合中的元素数
		System.out.println("size:"+c.size());				
		System.out.println("c:"+c);	
	}
}

高级特性：

/**
 * 
 */
package org.zst.collection;
import java.util.ArrayList;
import java.util.Collection;

/**
 * @author：zsyht
 * @date：2017-11-9下午2:28:31
 */
public class CollectionDemo2 {
	public static void main(String[] args) {
		//创建两个Collection集合对象
		Collection c1 = new ArrayList() ;
		Collection c2 = new ArrayList() ;
		
		//分别给c1,c2集合添加元素
		c1.add("abc1") ;
		c1.add("abc2") ;
		c1.add("abc3") ;
		c1.add("abc4") ;
		
		c2.add("abc4") ;
		c2.add("abc5") ;
		c2.add("abc6") ;
		c2.add("abc7") ;
		
		//boolean addAll(Collection c):添加一个集合中的所有元素
		System.out.println("addAll:"+c1.addAll(c2));
		
		//boolean removeAll(Collection c):删除一个算是删除
		System.out.println("removeAll:"+c1.removeAll(c2));
        //boolean containsAll(Collection c):包含所有算是包含
		System.out.println("containsAll:"+c1.containsAll(c2));
		
		//boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
		/**
		 * 面试题:
		 * A集合对B集合取交集,那么交集的元素去A集合里面了,并且返回值boolean表达的意识是A集合中的元素是否发生变化,如果发生变化,就返回true;否则,false
		 */
		System.out.println("retianAll:"+c1.retainAll(c2));
		
		//输出每个集合中的元素
		System.out.println("c1:"+c1);
		System.out.println("c2:"+c2);
	}
}

集合专有遍历方式：使用集合本身迭代功能遍历数组中的元素

Iterator iterator():迭代器

成员方法：object next():返回迭代的下一个元素

boolean hasNext():判断一个集合中是否有下一个可以迭代的元素

/**
 * 
 */
package org.zst.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * @author：zsyht
 * @date：2017-11-9下午3:16:15
 */
public class CollectionDemo4 {
	public static void main(String[] args) {
		Collection c = new ArrayList();//ArrayList是List的子实现类(存储和取出一致）
		c.add("hello");
		c.add("world");
		c.add("ssy");
		
		Iterator it = c.iterator();
		//Object obj = it.next();
		//System.out.println(obj);
		if(it.hasNext()){
		System.out.println(it.next());
		}
		if(it.hasNext()){
		System.out.println(it.next());
		}
		if(it.hasNext()){
		System.out.println(it.next());
		}
		if(it.hasNext()){
			System.out.println(it.next());
		}
	}
}

迭代器的两个注意事项：

1.存储自定义对象，使用迭代器遍历，it.next()方法不要使用多次，否则会异常

2.迭代器遍历使用whlie循环，也可以使用for循环，但使用for循环时，要将语句写在for循环里边

list集合：一个有序的集合，存储和取出元素是一致的，该集合中的元素可以重复

添加功能：void add(int index,Object element):在列表的指定位置插入指定元素

删除功能：Object remove(int index):移除列表中指定位置的元素，返回被删除的元素

获取功能：ListIterator listIterator():列表迭代器，List集合的专有遍历方式

替换：set(int index,Object element):用指定元素替换列表中指定位置的元素

/**
 * 
 */
package org.zst.collection;

import java.util.ArrayList;
import java.util.List;

/**
 * @author：zsyht
 * @date：2017-11-9下午8:51:00
 */
public class ListDemo2 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("ssy");
		list.add("zst");
		list.add("hello");
/*		System.out.println("remove:"+list.remove(2));
		System.out.println("list:"+list);*/
		System.out.println("set:"+list.set(2,"isafoolishman"));
		System.out.println("list:"+list);

	}
}