黑马程序员--Java基础之集合
来源:互联网 发布:fix you知乎 编辑:程序博客网 时间:2024/05/22 23:36
------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流!
Java集合整理
集合内容可分为两大部分Collection、Map
List:元素有序、可重复、有索引
凡是可操作角标的方法都是该体系的特有方法
增 add(index,element)
addAll(index,Collection);
删 remove(index);
改 set(index.element);
查 get(index);//获取指定位置的元素
subList(from,to);//获取字串,包含头不包含尾
indexOf();//获取制定元素的位置
listIterator();//列表迭代器
List集合特有的迭代器,ListIterator是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生ConcurrentModificationException异常。所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作。
如果想要其他的操作如添加、修改等,就需要使用其子接口:ListIterator.该接口只能通过List集合的listIterator方法获取。
List 考点!!!!
|--Vector 同步的 底层数据结构是数组 v1.0出现。被ArrayList替代了。枚举:Vector特有的取出方式,和迭代一
样,但因名字长而被迭代取代
----------------------------------------------------------------------------------------------------------------------------------------------
|--ArrayList 不同步的 底层数据结构是数组 查询速度快,增删慢 最常用
----------------------------------------------------------------------------------------------------------------------------------------------
|--LinkedList 底层数据结构是链表 增删快,查询慢
Set
|--HashSet 不同步 底层数据结构是哈希表
|--TreeSet 底层数据结构是二叉树
元素存取无序,唯一。
===>因为Set是存取无序的,所以Set的成员方法中没有get()方法(因为无序,每次获得的索引不一定相同,所以得到索引也就没有意义了)
从而也不能用一些需要用到索引的方法,如二分查找。
泛型:
JDK1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制
一.好处:
1.将运行时期出现问题ClassCastException,转移到了编译时期,方便程序员解决问题。让运行时期问题减少,安全。
2.避免了强制转换的麻烦
二.泛型格式:
通过<>来定义要操作的引用数据类型。
eg. ArrayList<String> al = new Arraylist<String>();
Iterator<String> it = new iterator();
在使用java提供的对象时,什么时候使用泛型呢?
通常在集合框架中很常见。只要见到<>就要定义泛型
其实<>就是用来接收类型的。当使用集合时,讲集合中要存储的数据类型作为参数传递到<>中即可。
Demo:
/*
泛型
*/
import java.util.*;
class GenericDemo
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>();
ts.add("cdd");
ts.add("abcd");
ts.add("dff");
ts.add("a");
Iterator<String> it = ts.iterator();
while (it.hasNext())
{
String s = it.next();
System.out.println(s);
}
}
}
class LenCompare implements Comparator<String>
{
public int compare(String o1,String o2)
{
int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num == 0)
return o1.compareTo(o2);
return num;
}
}
三.泛型类
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
什么时候定义泛型类?
当类中要操作的引用数据类型不确定的时候,早期定义Object完成扩展,现在定义泛型来完成扩展。
四.泛型方法
泛型类定义的泛型,在整个类中有效。如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。注意:泛型放在返回值类型的前面,不要放错位置
class Demo
{
public <T> void show(T t)
{
System.out.println("show:"+t);
}
public <Q> print(Q q)
{
System.out.println("print:"+q);
}
}
特殊之处:静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上
public static <Q> void method(Q q)
{
System.out.println("print:"+q);
}
五.泛型接口
interface Inter<T>
{
}
class InterImpl<T> implements Inter<T>
{
}
六.泛型限定
泛型限定是用于泛型扩展的
? 通配符,也可以理解成占位符
Demo:
import java.util.*;
class GenericDemo2
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
ArrayList<Integer> al2 = new ArrayList<Integer>();
al2.add(new Integer(4));
al2.add(5);
getColl(al);
getColl(al2);
}
public static void getColl(ArrayList<?> al)
{
Iterator<?> it = al.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
}
泛型的限定:
? extends E:可以接收E类型或者E的子类型。上限
? super E:可以接收E类型或者E的父类型。下限
Demo:上限
import java.util.*;
class GenericDemo3
{
public static void main(String[] args)
{
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("person1"));
al.add(new Person("person2"));
al.add(new Person("person3"));
printColl(al);
ArrayList<Student> al2 = new ArrayList<Student>();
al2.add(new Student("student1"));
al2.add(new Student("student2"));
al2.add(new Student("student3"));
printColl(al2);
}
public static void printColl(ArrayList<? extends Person> al)
{
Iterator<? extends Person> it = al.iterator();
while (it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
Demo:下限
import java.util.*;
class GenericDemo4
{
public static void main(String[] args)
{
TreeSet<Student> ts = new TreeSet<Student>(new comp());
ts.add(new Student("stu1"));
ts.add(new Student("stu9"));
ts.add(new Student("stu3"));
ts.add(new Student("stu6"));
Iterator<Student> it = ts.iterator();
while (it.hasNext())
{
System.out.println(it.next().getName());
}
TreeSet<Worker> ts2 = new TreeSet<Worker>(new comp());
ts2.add(new Worker("stu1"));
ts2.add(new Worker("stu9"));
ts2.add(new Worker("stu3"));
ts2.add(new Worker("stu6"));
Iterator<Worker> it2 = ts2.iterator();
while (it2.hasNext())
{
System.out.println(it2.next().getName());
}
}
}
class comp implements Comparator<Person>
{
public int compare(Person p1,Person p2)
{
return p1.getName().compareTo(p2.getName());
}
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
class Worker extends Person
{
Worker(String name)
{
super(name);
}
}
2.Map和Collection的区别?
3.基本功能:重点掌握 键集合keySet()以及值集合values()
(详见MapDemo.java 及 MapDemo2.java)
4.(重要代码!)Map集合遍历的两种方式,重点掌握第一种:通过键找值;
理解第二种:通过键值对对象找键和值。
(详见Map集合的两种遍历方式.bmp 及 MapDemo3.java 及 MapDemo4.java,MapDemo5.java)
Map集合:该集合存储键值对。一对一往里存,而且要保证键的唯一性。
Map共性方法
1.添加
put(K key, V value) 注:如果添加时,出现相同的键,那么后添加的值会覆盖原有键的值,并且put方法会返回被覆盖的值。
putAll(Map<? extends K,? extends V> m)
2.删除
clear()
remove(Object key)
3.判断
containsValue(Object value)
containsKey(Object key)
isEmpty()
4.获取
get(Object key) 注:可以通过get方法的返回值来判断一个键是否存在。通过返回值null来判断
size()
values()
和Map很像,其实Set底层就是使用了Map集合。
Demo:
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//添加元素。如果添加时,出现相同的键,那么后添加的值会覆盖原有键的值,并且put方法会返回被覆盖的值。
map.put("01","lisi1");
map.put("02","lisi2");
map.put("03","lisi3");
//判断
System.out.println("containsKey:"+map.containsKey("02"));//true
System.out.println("containsKey:"+map.containsKey("022"));//false
//删除
System.out.println("remove:"+map.remove("02"));//remove:lisi2
System.out.println("remove:"+map.remove("022"));//remove:null
//获取
System.out.println("get:"+map.get("03"));//get:lisi3
map.put("04",null);
System.out.println("get:"+map.get("04"));//get:null
//可以通过get方法的返回值来判断一个键是否存在。通过返回值null来判断
//获取map集合中所有的值
Collection<String> coll = map.values();
System.out.println(coll);//[lisi1, lisi3, null]
System.out.println(map);//{01=lisi1, 02=lisi2, 03=lisi3}
}
}
Map集合的两种取出方式:
1.Set<K> keySet()重点:将map中所有的键存入到Set集合中。因为Set具备迭代器,所以可以通过迭代方式取出所有键,再根据get方法,获取每一个键对应的值。
Map集合的取出原理:将map集合转成Set集合,再通过迭代器取出。
2.Set<Map.Entry<K,V>> entrySet() 重点:将Map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是:Map.Entry
Map.Entry Entry其实也是一个接口,它是Map接口中的一个内部接口。
interface Map
{
public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
Demo:
import java.util.*;
class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("01","lisi1");
map.put("02","lisi2");
map.put("03","lisi3");
map.put("04","lisi4");
//方式一:keySet
Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();
while (it.hasNext())
{
String key = it.next();
String value = map.get(key);
System.out.println("key:"+key+",value:"+value);
}
//方式二:entrySet
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it2 = entrySet.iterator();
while (it2.hasNext())
{
Map.Entry<String,String> me = it2.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"::"+value);
}
}
}
Map子类对象
|--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。 JDK1.0 效率低
|--HashMap:底层是哈希表数据结构,允许使用null键null值,该集合是不同步的。JDK1.2 效率高 }二者关系
|--TreeMap:底层是二叉树数据结构,线程不同步。可以用于给map集合中的键进行排序
和Set很像,其实Set底层就是使用了Map集合
Java集合整理
集合内容可分为两大部分Collection、Map
一、Collection
(一)List(抽象类)
List集合判断元素是否相同,依据的是元素的equals方法。List:元素有序、可重复、有索引
凡是可操作角标的方法都是该体系的特有方法
增 add(index,element)
addAll(index,Collection);
删 remove(index);
改 set(index.element);
查 get(index);//获取指定位置的元素
subList(from,to);//获取字串,包含头不包含尾
indexOf();//获取制定元素的位置
listIterator();//列表迭代器
List集合特有的迭代器,ListIterator是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生ConcurrentModificationException异常。所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作。
如果想要其他的操作如添加、修改等,就需要使用其子接口:ListIterator.该接口只能通过List集合的listIterator方法获取。
List 考点!!!!
|--Vector 同步的 底层数据结构是数组 v1.0出现。被ArrayList替代了。枚举:Vector特有的取出方式,和迭代一
样,但因名字长而被迭代取代
----------------------------------------------------------------------------------------------------------------------------------------------
|--ArrayList 不同步的 底层数据结构是数组 查询速度快,增删慢 最常用
----------------------------------------------------------------------------------------------------------------------------------------------
|--LinkedList 底层数据结构是链表 增删快,查询慢
(二)Set
Set集合功能和Collection是一致的。Set
|--HashSet 不同步 底层数据结构是哈希表
|--TreeSet 底层数据结构是二叉树
元素存取无序,唯一。
===>因为Set是存取无序的,所以Set的成员方法中没有get()方法(因为无序,每次获得的索引不一定相同,所以得到索引也就没有意义了)
从而也不能用一些需要用到索引的方法,如二分查找。
二、泛型
概念,格式,用法。泛型:
JDK1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制
一.好处:
1.将运行时期出现问题ClassCastException,转移到了编译时期,方便程序员解决问题。让运行时期问题减少,安全。
2.避免了强制转换的麻烦
二.泛型格式:
通过<>来定义要操作的引用数据类型。
eg. ArrayList<String> al = new Arraylist<String>();
Iterator<String> it = new iterator();
在使用java提供的对象时,什么时候使用泛型呢?
通常在集合框架中很常见。只要见到<>就要定义泛型
其实<>就是用来接收类型的。当使用集合时,讲集合中要存储的数据类型作为参数传递到<>中即可。
Demo:
/*
泛型
*/
import java.util.*;
class GenericDemo
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>();
ts.add("cdd");
ts.add("abcd");
ts.add("dff");
ts.add("a");
Iterator<String> it = ts.iterator();
while (it.hasNext())
{
String s = it.next();
System.out.println(s);
}
}
}
class LenCompare implements Comparator<String>
{
public int compare(String o1,String o2)
{
int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num == 0)
return o1.compareTo(o2);
return num;
}
}
三.泛型类
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
什么时候定义泛型类?
当类中要操作的引用数据类型不确定的时候,早期定义Object完成扩展,现在定义泛型来完成扩展。
四.泛型方法
泛型类定义的泛型,在整个类中有效。如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。注意:泛型放在返回值类型的前面,不要放错位置
class Demo
{
public <T> void show(T t)
{
System.out.println("show:"+t);
}
public <Q> print(Q q)
{
System.out.println("print:"+q);
}
}
特殊之处:静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上
public static <Q> void method(Q q)
{
System.out.println("print:"+q);
}
五.泛型接口
interface Inter<T>
{
}
class InterImpl<T> implements Inter<T>
{
}
六.泛型限定
泛型限定是用于泛型扩展的
? 通配符,也可以理解成占位符
Demo:
import java.util.*;
class GenericDemo2
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
ArrayList<Integer> al2 = new ArrayList<Integer>();
al2.add(new Integer(4));
al2.add(5);
getColl(al);
getColl(al2);
}
public static void getColl(ArrayList<?> al)
{
Iterator<?> it = al.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
}
泛型的限定:
? extends E:可以接收E类型或者E的子类型。上限
? super E:可以接收E类型或者E的父类型。下限
Demo:上限
import java.util.*;
class GenericDemo3
{
public static void main(String[] args)
{
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("person1"));
al.add(new Person("person2"));
al.add(new Person("person3"));
printColl(al);
ArrayList<Student> al2 = new ArrayList<Student>();
al2.add(new Student("student1"));
al2.add(new Student("student2"));
al2.add(new Student("student3"));
printColl(al2);
}
public static void printColl(ArrayList<? extends Person> al)
{
Iterator<? extends Person> it = al.iterator();
while (it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
Demo:下限
import java.util.*;
class GenericDemo4
{
public static void main(String[] args)
{
TreeSet<Student> ts = new TreeSet<Student>(new comp());
ts.add(new Student("stu1"));
ts.add(new Student("stu9"));
ts.add(new Student("stu3"));
ts.add(new Student("stu6"));
Iterator<Student> it = ts.iterator();
while (it.hasNext())
{
System.out.println(it.next().getName());
}
TreeSet<Worker> ts2 = new TreeSet<Worker>(new comp());
ts2.add(new Worker("stu1"));
ts2.add(new Worker("stu9"));
ts2.add(new Worker("stu3"));
ts2.add(new Worker("stu6"));
Iterator<Worker> it2 = ts2.iterator();
while (it2.hasNext())
{
System.out.println(it2.next().getName());
}
}
}
class comp implements Comparator<Person>
{
public int compare(Person p1,Person p2)
{
return p1.getName().compareTo(p2.getName());
}
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
class Worker extends Person
{
Worker(String name)
{
super(name);
}
}
三、Map
1.基本概念2.Map和Collection的区别?
3.基本功能:重点掌握 键集合keySet()以及值集合values()
(详见MapDemo.java 及 MapDemo2.java)
4.(重要代码!)Map集合遍历的两种方式,重点掌握第一种:通过键找值;
理解第二种:通过键值对对象找键和值。
(详见Map集合的两种遍历方式.bmp 及 MapDemo3.java 及 MapDemo4.java,MapDemo5.java)
Map集合:该集合存储键值对。一对一往里存,而且要保证键的唯一性。
Map共性方法
1.添加
put(K key, V value) 注:如果添加时,出现相同的键,那么后添加的值会覆盖原有键的值,并且put方法会返回被覆盖的值。
putAll(Map<? extends K,? extends V> m)
2.删除
clear()
remove(Object key)
3.判断
containsValue(Object value)
containsKey(Object key)
isEmpty()
4.获取
get(Object key) 注:可以通过get方法的返回值来判断一个键是否存在。通过返回值null来判断
size()
values()
和Map很像,其实Set底层就是使用了Map集合。
Demo:
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//添加元素。如果添加时,出现相同的键,那么后添加的值会覆盖原有键的值,并且put方法会返回被覆盖的值。
map.put("01","lisi1");
map.put("02","lisi2");
map.put("03","lisi3");
//判断
System.out.println("containsKey:"+map.containsKey("02"));//true
System.out.println("containsKey:"+map.containsKey("022"));//false
//删除
System.out.println("remove:"+map.remove("02"));//remove:lisi2
System.out.println("remove:"+map.remove("022"));//remove:null
//获取
System.out.println("get:"+map.get("03"));//get:lisi3
map.put("04",null);
System.out.println("get:"+map.get("04"));//get:null
//可以通过get方法的返回值来判断一个键是否存在。通过返回值null来判断
//获取map集合中所有的值
Collection<String> coll = map.values();
System.out.println(coll);//[lisi1, lisi3, null]
System.out.println(map);//{01=lisi1, 02=lisi2, 03=lisi3}
}
}
Map集合的两种取出方式:
1.Set<K> keySet()重点:将map中所有的键存入到Set集合中。因为Set具备迭代器,所以可以通过迭代方式取出所有键,再根据get方法,获取每一个键对应的值。
Map集合的取出原理:将map集合转成Set集合,再通过迭代器取出。
2.Set<Map.Entry<K,V>> entrySet() 重点:将Map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是:Map.Entry
Map.Entry Entry其实也是一个接口,它是Map接口中的一个内部接口。
interface Map
{
public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
Demo:
import java.util.*;
class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("01","lisi1");
map.put("02","lisi2");
map.put("03","lisi3");
map.put("04","lisi4");
//方式一:keySet
Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();
while (it.hasNext())
{
String key = it.next();
String value = map.get(key);
System.out.println("key:"+key+",value:"+value);
}
//方式二:entrySet
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it2 = entrySet.iterator();
while (it2.hasNext())
{
Map.Entry<String,String> me = it2.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"::"+value);
}
}
}
Map子类对象
|--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。 JDK1.0 效率低
|--HashMap:底层是哈希表数据结构,允许使用null键null值,该集合是不同步的。JDK1.2 效率高 }二者关系
|--TreeMap:底层是二叉树数据结构,线程不同步。可以用于给map集合中的键进行排序
和Set很像,其实Set底层就是使用了Map集合
0 0
- 黑马程序员-java基础之Map集合
- 黑马程序员---java基础之集合Collection
- 黑马程序员—java基础之集合
- <<黑马程序员>>JAVA基础之集合
- 黑马程序员—JAVA基础之集合
- 黑马程序员--JAVA基础之集合类
- 黑马程序员--Java基础之集合
- 黑马程序员--Java基础之集合类
- 黑马程序员 java基础之list集合
- 黑马程序员 java基础之set集合
- 黑马程序员 java基础之Map集合
- 黑马程序员java基础之Map集合
- 黑马程序员--java基础复习之集合
- 黑马程序员---java基础之集合Set
- 黑马程序员----java基础之Map集合
- 黑马程序员-JAVA基础之集合框架
- 黑马程序员-------Java基础-------集合之Map
- 黑马程序员-java基础之集合List,Set集合
- Android 蓝牙开发入门
- PHP GD库及jpgraph的安装与配置
- 网络通信的工作原理
- linux shell中的$0,$?,$!和<<'END'
- 从post获取的html源码的编码问题
- 黑马程序员--Java基础之集合
- JAVA设计模式之 建造者模式【Builder Pattern】
- 数据结构第三章思维导图
- 模拟登陆网站 之 C#版(内含两种版本的完整的可运行的代码)
- 黑马程序员-day14集合
- c++项目包含纯c文件编译方法
- Google Guice之牛刀小试
- 题目1510:替换空格
- s5pv210驱动之流水灯程序2