黑马程序员_java集合1

最新推荐文章于 2022-01-06 17:26:46 发布

zengpangzp

最新推荐文章于 2022-01-06 17:26:46 发布

阅读量296

点赞数

本文链接：https://blog.csdn.net/zengpangzp/article/details/46984331

版权

集合的存在的原因：

Java是面向对象的语言，描述的事物都是以对象的形式体现，对象多了就需要储存，但是又不确定存储的个数，所以有了集合。

集合有哪些特点？

1.集合只用来存储对象

2.集合可以存储不同类型的对象

3.集合的长度是可变化的

但是1.5后有了泛型新特性，所以一般一个集合存储的还是同一个对象。

集合和数组的区别：

1.集合只能存储对象,而数组既能存储对象,又能存储基本数据类型

2.集合的长度是可变的，而数组的长度是固定的

3.集合可以存储不同类型的对象，而数组只能存储同一类型的数据

集合因为内部的数据结构不同，所以有许多集合，但是又有共性方法，不断向上抽取，于是就有了集合体系，如下：

集合框架的构成：

Collection:

共性方法：

add();添加元素

clear();移除所有元素

equals();比较集合中指定对象是否相等

contains();是否包含指定元素

iterator();迭代器

remove();移除指定元素，如果存在

size();返回集合元素数

示例：

import java.util.*;
class CollectionDemo
{
	public static void main(String[] args) 
	{
		Collection coll = new ArrayList();
		coll.add("张三");//添加元素
		coll.add("王五");
		coll.add("李四");
		sop(coll.equals("张三"));//是否相等，比较的是引用
		sop(coll.contains("李四"));//是否包含
		sop(coll.size());//集合的元素数
		sop(coll.remove("王五"));//移除”王五“这个元素
		sop(coll.size());//集合的元素数
		coll.clear();//移除所有元素
		sop(coll.size());//集合的元素数
		Iterator it = coll.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

泛型类：

是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

泛型的好处就是把运行时的问题，改成了编译期

定义泛型在class上，则全类都明确类型如下：

class Demo<T>

{

public void show<T t>

{

Syso(t);

}

public void print<T t1>

{

Syso(t1);

}

定义泛型在方法上，则每个方法有每个方法的类型如下：

class Demo

{

public <T> void show<T t>

{

Syso(t);

}

public <Q> void print <Q q1>

{

Syso(q1);

}

泛型定义在class上，同时定义泛型在方法上：

class Demo<T>

{

public void show<T t>

{

Syso(t);

}

public <Q> void print <Q q1>

{

Syso(q1);

}

泛型特殊之处：

静态方法不可以访问类上定义的泛型。

如果静态方法定义的类型不确定，则可以将泛型定义在方法上。

注意：泛型必须放在静态修饰符的后面。

class Demo<T>

{

public void show<T t>

{

Syso(t);

}

public static <Q> void print <Q q1>

{

Syso(q1);

}

泛型限定：

? 通配符，也可以理解为占位符。

？ extends E:可以接受E类型或者E类型的子类，上限。

？ super E:可以接受E类型或者E类型的父类，下限。

|--List:元素是有序的，元素可以重复，该体系有索引。判断元素是否相同，依据的是元素的equals方法，特有方法，凡是操作角标的方法都是该体系特有的方法。

增：

add(index,element);

addAll(index,collection);

删:

remove(index);

改:

set(index,element);

查:

get(index);

sbuList(from,to);包含头不包含尾

listIterator();

示例：

package arraylist;
import java.util.*;
public class ArrayListTest {

	public static void main(String[] args) {
//list的体系中特有方法
		List<String> al = new ArrayList<String>();//定义一个List集合
		List<String> a2 = new ArrayList<String>();//定义一个List集合
		//给al集合添加元素
		al.add("javaTest1");
		al.add("javaTest2");
		al.add("javaTest3");
		//给a2集合添加元素
		a2.add("javaTest3");
		a2.add("javaTest4");
		a2.add("javaTest5");
		al.add(2, "javaTest2.5");//从指定位置添加该元素
		al.addAll(2, a2);//从指定位置添加该集合中所有的元素
		al.remove(5);//移除角标为5的元素
		al.set(5, "javaTest6");//设置角标为5的元素值
		System.out.println(al.indexOf("javaTest2"));//返回该元素的角标
		System.out.println(al.get(5));//得到角标为5的元素
		System.out.println("-------------------------------------------------------");
		List<String> l = al.subList(0, 5);//截取集合中的一部分，包含头不包含尾
		//List特有取出方式
		for(int i=0;i<l.size();i++)
		{
			System.out.println(al.get(i));
		}
		System.out.println("-------------------------------------------------------");
		//迭代器取出方式
		Iterator<String> it =al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	

}

|--ArrayList:底层的数据结构就是数组结构，特点查询速度快，增删稍慢，线程不同步。

题目：一个ArrayList对象aList中存有若干个字符串元素，现欲遍历该ArrayList对象，删除其中所有值为"abc"的字符串元素，请用代码实现。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class ArrayListDemo{
public static void main(String[] args)
	{
		ArrayList<String> aList = new ArrayList<String>(); 
		//添加若干元素
		aList.add("abvc");
		aList.add("abc");
		aList.add("abc");
		aList.add("abbbc");
		aList.add("abccc");
		System.out.println(aList);
		//通过list迭代器删除集合中值为abc的元素
		ListIterator<String> lit = aList.listIterator();
		while(lit.hasNext())
		{
			if(lit.next().equals("abc"))
				lit.remove();
		}
		//通过迭代器遍历去除abc后的集合
		Iterator<String> it = aList.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

|--LinkedList:底层使用链表数据结构，特点增删快，查询慢。

特有方法：

addFirst();addLast();添加元素

getFirst();getLast();获取元素但不删除元素，如果集合中没有元素会出现NoSuchElementException

removeFirst();removeLast();获取元素且删除元素，如果集合中没有元素会出现NosuchElementException

示例：

import java.util.*;
class LinkedDemo
{
	public static void main(String[] args) 
	{
		LinkedList<String>  ll  = new LinkedList<String>();
		//添加元素
		ll.add("剑圣");
		ll.add("剑姬");
		ll.add("剑魔");
		ll.addFirst("蛮三刀");//在首位添加元素
		ll.addLast("赵信");//在末尾添加元素
		System.out.println(ll.getFirst());//获取第一个元素但不删除元素
		System.out.println(ll.getLast());//获取最后一个元素但不删除元素
		System.out.println(ll.removeFirst());//获取第一个元素且删除元素
		System.out.println(ll.removeLast());//获取最后一个元素且删除元素
		System.out.println(ll);//输出元素
	}
}

在JDK1.6版本后被替代了：

offerFirst();offerLast();添加元素

peekFirst();peekLast();获取元素但不删除元素，如果集合中没有元素会返回null

pollFirst();pollLast();获取元素且删除元素

获取元素且删除元素，如果集合中没有元素会返回null

示例：

import java.util.*;
class LinkedDemo
{
	public static void main(String[] args) 
	{
		LinkedList<String>  ll  = new LinkedList<String>();
		//添加元素
		ll.add("剑圣");
		ll.add("剑姬");
		ll.add("剑魔");
		ll.offerFirst("蛮三刀");//在首位添加元素
		ll.offerLast("赵信");//在末尾添加元素
		System.out.println(ll.peekFirst());//获取第一个元素但不删除元素
		System.out.println(ll.peekLast());//获取最后一个元素但不删除元素
		System.out.println(ll.pollFirst());//获取第一个元素且删除元素
		System.out.println(ll.pollLast());//获取最后一个元素且删除元素
		System.out.println(ll);//输出元素
	}
}

|--Vector:底层的数据结构就是数组结构，线程同步，被 ArrayList给替代了。但其有一个特有取出方法，枚举：

Enumeration elements()但由于字符太长，所以被 Iterator取代了，;

示例:

import java.util.*;

class VectorDemo

{

public static void main(String[] args)

{

Vector<String> ve = new Vector<String>();//定义一个Vector集合

//往集合中添加元素

ve.add("妖姬");

ve.add("狐狸");

ve.add("琴女");

Enumeration<String> en = ve.elements();//返回一个枚举对象

while(en.hasMoreElements())//此枚举是否还有更多的元素

{

System.out.println(en.nextElement());//输出枚举中的元素

}

import java.util.*;

class VectorDemo

{

public static void main(String[] args)

{

Vector<String> ve = new Vector<String>();//定义一个Vector集合

//往集合中添加元素

ve.add("妖姬");

ve.add("狐狸");

ve.add("琴女");

Enumeration<String> en = ve.elements();//返回一个枚举对象

while(en.hasMoreElements())//此枚举是否还有更多的元素

{

System.out.println(en.nextElement());//输出枚举中的元素

}

|--Set;元素无序(存入取出的顺序不一定一致)元素不可以重复。

其功能和collection一致。

示例：

import java.util.*;
class SetDemo 
{
	public static void main(String[] args) 
	{
		Set<String> s = new HashSet<String>();

		s.add("流浪法师");//添加元素
		s.add("德玛西亚");
		s.add("德邦皇子");
		sop(s.equals("流浪法师"));//是否相等，比较的是引用
		sop(s.contains("德邦皇子"));//是否包含
		sop(s.size());//集合的元素数
		sop(s.remove("德玛西亚"));//移除”<span style="font-family: Arial, Helvetica, sans-serif;">德玛西亚</span><span style="font-family: Arial, Helvetica, sans-serif;">“这个元素</span>
		sop(s.size());//集合的元素数
		//coll.clear();//移除所有元素
		sop(s.size());//集合的元素数
		Iterator<String> it = s.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}

	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

import java.util.*;
class HashSetDemo 
{
	public static void main(String[] args) 
	{
		HashSet<Person> hs = new HashSet<Person>();//定义一个hashset集合
		//添加元素
		hs.add(new Person(20,"皇子"));
		hs.add(new Person(21,"赵信"));
		hs.add(new Person(22,"德玛"));
		hs.add(new Person(20,"皇子"));
		System.out.println(hs.contains(new Person(20,"皇子")));//比较的是复写hashcode和复写equals所以为true
		Iterator<Person> it = hs.iterator();
		//迭代器遍历集合
		while(it.hasNext())
		{
			Person p = it.next();
			System.out.println(p.getName()+":::::"+p.getAge());
		}
	}
}
//定义一个Person类
class Person
{
	private int age ;
	private String name;
	//定义一个有参构造方法
	Person(int age, String name)
	{
		this.age=age;
		this.name=name;
	}
	public int getAge()
	{
		return this.age;
	}
	public String getName()
	{
		return name;
	}
	//复写hashCode方法
	public int hashCode()
	{
		return this.name.hashCode()+this.age*66;
	}
	//复写equals方法
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			throw new RuntimeException("类型不匹配");
		Person p = (Person)obj;
		return this.name.equals(p.name)&&this.age==p.age;
	}

|--TreeSet:可以对Set集合中的元素进行排序。

底层数据结构是二叉树；保证元素唯一性的依据，

compareTo方法，return 0。

TreeSet排序的第一种方式，让元素自身具备比较性。

需要实现Comparable接口，覆盖compareTo方法。

这种方式也称为元素的自然排序，或者叫默认顺序。

理解二叉树的原理，比较compareTo,返回正数，往右边；返回负数，往左边，从小到大取出；返回0，则表示相同只存一次。

示例：

import java.util.*;
class TreeSetDemo1
{
	public static void main(String[] args) 
	{
		TreeSet<Person> ts = new TreeSet<Person>();//定义一个TreeSet集合
		//往集合中添加元素
		ts.add(new Person(20,"光辉"));
		ts.add(new Person(20,"皇子"));
		ts.add(new Person(21,"赵信"));
		ts.add(new Person(22,"德玛"));
		ts.add(new Person(20,"皇子"));
		Iterator<Person> it = ts.iterator();
		//迭代器遍历集合
		while(it.hasNext())
		{
			Person p = it.next();
			System.out.println(p.getName()+":::::"+p.getAge());
		}
	}
}
//定义一个Person类
class Person implements Comparable<Person>
{
	private int age ;
	private String name;
	//定义一个有参构造方法
	Person(int age, String name)
	{
		this.age=age;
		this.name=name;
	}
	public int getAge()
	{
		return this.age;
	}
	public String getName()
	{
		return name;
	}
	//复写compareTo方法，依据年龄大小来排序，若年龄相同则依据姓名排序
	public int compareTo(Person p)
	{
		int num = new Integer(this.age).compareTo(new Integer(p.age));
		if(num==0)
			return this.name.compareTo(p.name);
		return num;
	}
}

TreeSet第二种排序方式。

当元素自身不具备比较性时，或者具备的比较性不是自己所需要的，这时就需要让集合自身具备比较性。

定义一个类，实现comparator接口，覆盖compare方法。

当两种排序方式都存在时以比较器为主，即第二种方式。

示例：

import java.util.*;
class  TreeSetDemo2
{
	public static void main(String[] args) 
	{
		TreeSet<Person> ts = new TreeSet<Person>(new Mycom());//定义一个TreeSet集合,
		//往集合中添加元素
		ts.add(new Person(20,"光辉"));
		ts.add(new Person(20,"皇子"));
		ts.add(new Person(21,"赵信"));
		ts.add(new Person(22,"德玛"));
		ts.add(new Person(20,"皇子"));
		Iterator<Person> it = ts.iterator();
		//迭代器遍历集合
		while(it.hasNext())
		{
			Person p = it.next();
			System.out.println(p.getName()+":::::"+p.getAge());
		}
	}
}
//定义一个比较器
class Mycom implements Comparator<Person>//实现Comparator接口
{
	public int compare(Person p1,Person p2)//复写compare方法
	{
		//依据年龄大小来排序，若年龄相同则依据姓名排序
		int num = new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
		if(num==0)
			return p1.getName().compareTo(p2.getName());
		return num;
	}
}
//定义一个Person类
class Person
{
	private int age ;
	private String name;
	//定义一个有参构造方法
	Person(int age, String name)
	{
		this.age=age;
		this.name=name;
	}
	public int getAge()
	{
		return this.age;
	}
	public String getName()
	{
		return name;
	}
}