黑马程序员——集合2

最新推荐文章于 2016-01-05 21:23:26 发布

bingniu

最新推荐文章于 2016-01-05 21:23:26 发布

阅读量451

点赞数

分类专栏： Java学习笔记文章标签： android java 软件开发黑马程序员

本文链接：https://blog.csdn.net/bingniu/article/details/45043361

版权

Java学习笔记专栏收录该内容

17 篇文章 0 订阅

订阅专栏

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

< 今日心情 >放掉懒惰，再加上一份坚持

一、List

1.操作序列方法

通过角标获取元素：

get(int index)

通过元素获取角标：

indexOf(Object o)

lastIndexOf(Object o)

通过角标修改（删除）元素：

subList(int fromIndex,int toIndex)

set(int index,E element)

remove(int index)

equals：

集合元素中本身的方法，判断两个对象是否相等。

2.ArrayList

底层数据结构使用数组结构

特点：

查找速度快

增删速度慢

线程不同步

迭代器

Iterator

hasNext()

next()

remove()

ListIterator

--

add(E e)

set(E e)

hasPrevious()

previous()

previousIndex()

nextIndex()

import java.util.*;
class Student
{
	String name;
	int age;
	public Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public boolean equals(Object o)
	{
		Student s;
		if(o instanceof Student)
		{
			s=(Student)o;
			System.out.println("\n本人："+this.toString());
			System.out.println("参与比较的人："+s.toString());
			return s.name==this.name&&s.age==this.age;
		}
		return false;
	}
	public String toString()
	{
		return "name:"+this.name+" age:"+this.age;
	}
}
class  ArrayListDemo
{
	public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();
		//添加元素
		al.add(new Student("zhang01",15));
		al.add(new Student("zhang02",4));
		al.add(new Student("zhang01",15));
		al.add(new Student("zhang02",5));
		//查找zhang02,5
		int z1=al.indexOf(new Student("zhang02",5));
		if(z1!=-1)
		{
			//删除该学生
			System.out.println("zhang02,5在："+z1);
			System.out.println("删除学生："+al.remove(z1));
		}
		for(Iterator i=al.iterator();i.hasNext();System.out.println(i.next().toString())){}
	}
}

3.LinkedList

底层数据结构使用链表数据结构

特点：

查找速度慢

增删速度快

线程不同步

迭代器

Iterator

迭代是取出集合中元素的一种方法。

ListIterator

List集合特有迭代器，Iterator的子接口

该迭代器可以可以通过前后两个方向对集合进行访问，取出元素，删除元素，修改元素，添加元素

链表方法

----添加元素----

push(E e)

addFirst(E e)
add(E e)

addLast(E e)

----获取元素E----

peek()

getFirst()

getLast()

----移除元素E----

pop()

poll()

pollFirst()

pollLast()

import java.util.*;
class Student
{
	String name;
	int age;
	public Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public boolean equals(Object o)
	{
		Student s;
		if(o instanceof Student)
		{
			s=(Student)o;
			System.out.println("\n本人："+this.toString());
			System.out.println("参与比较的人："+s.toString());
			return s.name==this.name&&s.age==this.age;
		}
		return false;
	}
	public String toString()
	{
		return "name:"+this.name+" age:"+this.age;
	}
}
class LinkedListDemo 
{
	public static void main(String[] args) 
	{
		LinkedList l=new LinkedList();
		l.add(new Student("zhang01",15));
		l.add(new Student("zhang02",4));
		l.add(new Student("zhang03",15));
		l.add(new Student("zhang04",5));
		l.push(new Student("li01",11));
		for(ListIterator i=l.listIterator();i.hasNext();)
		{
			if(!i.hasPrevious())
			{
				i.add(new Student("王班长",8));
				System.out.println("previous:"+i.previous());
			}
			System.out.println("next:"+i.next());
		}
		System.out.println("poll一个元素:"+l.poll());
		System.out.println("poll一个元素:"+l.poll());
		System.out.println("pop一个元素："+l.pop());
	}
}

二、set

1.HasSet

特点

数据结构是哈希表

线程不同步

保证元素唯一的依据：

对象中的hashCode值是否相等，

若hashCode值相等，调用equals方法判断，

若equals返回true则两个元素相等。

import java.util.*;
class Student
{
	String name;
	int age;
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int hashCode()
	{
		return name.hashCode()+age*17;
	}
	public boolean equals(Object o)
	{
		Student s;
		if(o instanceof Student)
		{
			s=(Student)o;
			return this.name==s.name&&this.age==s.age;
		}
		return false;
	}
	public String toString()
	{
		return "name:"+this.name+" age:"+this.age;
	}
}
class  HashSetDemo
{
	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();
		hs.add(new Student("zhang01",10));
		hs.add(new Student("zhang02",11));
		hs.add(new Student("zhang03",30));
		hs.add(new Student("zhang04",17));
		hs.add(new Student("zhang01",10));
		for(Iterator i=hs.iterator();i.hasNext();System.out.println("迭代输出："+i.next())){}
	}
}

2.TreeSet

特点

数据结构是二叉树

可以对集合中元素进行排序

排序的依据：

元素是符合Comparable接口规则的类的对象，根据对象中CompareTo方法的返回值(int)判断

创建集合的时候传入一个比较器，改比较器是Comparator的子类对象，根据对象中Compare方法的返回值(int)判断

当以上两个都满足时，以传入的比较器为主。

import java.util.*;
class Student implements Comparable
{
	String name;
	int age;
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String toString()
	{
		return "name:"+this.name+" age:"+this.age;
	}

	public int compareTo(Object o)//实现Comparable中的方法，将存的对象将调用此函数与已存的对象比较
	{
		if(!(o instanceof Student))
		{
			throw new RuntimeException("is not student");
		}
		Student s=(Student)o;
		System.out.println("将存数据:"+this.name+"——"+this.age+"\n"+"已存数据:"+s.name+"——"+s.age+"\n");
		if(this.name==s.name)
			return  new Integer(this.age).compareTo(new Integer(s.age));
		return this.name.compareTo(s.name);
	}
}
class  TreeSetDemo
{
	public static void main(String[] args) 
	{
		TreeSet ts1=new TreeSet();
		add(ts1);
		for(Iterator i=ts1.iterator();i.hasNext();System.out.println("迭代输出："+i.next())){}
	}

	public static void add(Set s)
	{
		s.add(new Student("zhang15",10));
		s.add(new Student("zhang11",11));
		s.add(new Student("zhang03",30));
		s.add(new Student("zhang12",17));
		s.add(new Student("zhang22",17));
		s.add(new Student("zhang21",10));
		s.add(new Student("zhang23",10));
		s.add(new Student("zhang23",9));
	}
}
import java.util.*;
class Student
{
	String name;
	int age;
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String toString()
	{
		return "name:"+this.name+" age:"+this.age;
	}
}
class myCompare implements Comparator
{
	public int compare(Object o1,Object o2)//实现comparator中的方法
	{
		Student s1,s2;
		if(!(o1 instanceof Student||o2 instanceof Student))
		{
			return -1;
		}
		s1=(Student)o1;
		s2=(Student)o2;
		System.out.println("将存数据:"+s1.name+"——"+s1.age+"\n"+"已存数据:"+s2.name+"——"+s2.age+"\n");
		if(s1.name==s2.name)
			return  new Integer(s2.age).compareTo(new Integer(s1.age));
		return s2.name.compareTo(s1.name);
	}
}
class  TreeSetDemo
{
	public static void main(String[] args) 
	{
	    /*
	        创建对象的时候传入一个比较器
	        改比较器是符合Comparator接口规则的类的对象
	    */
		TreeSet ts2=new TreeSet(new myCompare());
		add(ts2);
		for(Iterator i=ts2.iterator();i.hasNext();System.out.println("迭代输出："+i.next())){}
	}

	public static void add(Set s)
	{
		s.add(new Student("zhang15",10));
		s.add(new Student("zhang11",11));
		s.add(new Student("zhang03",30));
		s.add(new Student("zhang12",17));
		s.add(new Student("zhang22",17));
		s.add(new Student("zhang21",10));
		s.add(new Student("zhang23",10));
		s.add(new Student("zhang23",9));
	}
}

三、泛型

1.泛型的好处

提高了程序的安全性
将运行期遇到的问题转移到了编译期
省去了类型强转的麻烦

泛型类的出现优化了程序设计

2.泛型的定义

定义在接口上

定义在接口名后

定义在类上

定义在类名后

定义在方法上

定义在返回值类型前

注：

方法上既可以使用类上的泛型，也可以重新定义泛型

静态方法不能使用类上的泛型

3.泛型限定

<? extends E>

该泛型只接受E类及其子类的类型

<? super E>

该泛型只接受E类及其父类的类型

import java.util.*;
class People
{
	private String name;
	private int age;
	public People(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class Student extends People
{
	Student(String name,int age)
	{
		super(name,age);
	}
	void study()
	{
		System.out.println("好好学习，天天向上");
	}
}

class Teacher extends People
{
	Teacher(String name,int age)
	{
		super(name,age);
	}
	void teach()
	{
		System.out.println("我的学生都爱学习！");
	}
}
class MyCompare implements Comparator
      
      
       
       
{
	public int compare(People p1,People p2)//实现comparator中的方法,
	                                       //实现接口中的泛型规定了People类，此处接收数据类型必须保持一致
	{
		if(p1.getName()==p2.getName())
			return  new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
		return p1.getName().compareTo(p2.getName());
	}
}
class  GenericDemo
{
	public static void main(String[] args) 
	{
		MyCompare mp=new MyCompare();//new了一个比较器
		TreeSet
       
       
        
         ts1=new TreeSet
        
        
         
         (mp);//Student是People的子类，可以使用mp
		ts1.add(new Student("zhang15",10));
		ts1.add(new Student("zhang11",11));
		ts1.add(new Student("zhang03",30));
		ts1.add(new Student("zhang12",17));
		ts1.add(new Student("zhang11",17)
		{
			void study()
			{
				System.out.println("快乐的玩耍 ^_^");
			}
		});
		
		for(Iterator
         
         
          
           i=ts1.iterator();i.hasNext();)
		{
			Student s=i.next();
			s.study();
			System.out.println("我是学生："+s.getName()+" ："+s.getAge());
			
			System.out.println();
		}
		System.out.println("---------------------------");
		TreeSet
          
          
            ts2=new TreeSet 
           
             (mp);//Teacher是People的子类，也可以使用mp ts2.add(new Teacher("Miss li01",33)); ts2.add(new Teacher("Miss li07",37)); ts2.add(new Teacher("Miss li05",39)); ts2.add(new Teacher("Miss li07",37)); for(Iterator 
            
              i=ts2.iterator();i.hasNext();) { Teacher t=i.next();//集合中元素已经限定为Teacher类对象，不必判断，泛型避免了强转的麻烦。 t.teach(); System.out.println("我是老师："+t.getName()+" ："+t.getAge()); System.out.println(); } } }

bingniu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——集合2

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------放掉懒惰，再加上一份坚持一、List1.操作序列方法通过角标获取元素：get(int index)通过元素获取角标：indexOf(Object o)lastIndexOf(Obje
复制链接

扫一扫