------- android培训、java培训、期待与您交流！ ----------
前言：通过观看毕向东老师的java基础视频，查漏补缺，将一些自己掌握的还不牢固的知识写出来，希望和大家交流分享。
1.集合框架
1.集合类的出现原因：为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
2.java集合框架的构成，由于数据结构的不同，有不同的集合，也叫容器。如下图：
3.与数组相比，集合的优势： 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
2.Collection类
1.Collection的结构：
Collection
|--List//元素是有序的，元素可以重复。因为该集合体系有索引。
|--Set//元素是无序的，元素不可以重复。
2.Collection接口中常见方法1）add(Object obj); //添加元素，add方法的参数类型是Object。以便于接收任意类型对象。
2） 删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3）判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4）size();//获取个数，集合长度
注：集合中存储的都是对象的引用（地址）。
3.迭代1） 迭代是取出集合中元素的一种方式。
2）Iterator规则：对于集合的元素取出这个动作被定义成了内部类，可以直接访问集合内部的元素。对每一个容器的数据结构不同，所以取出的动作细节也不一样。
但是都具有共性内容： 判断和取出。那么就可以将这些共性抽取。 那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。
通过一个对外提供的方法：iterator();，来获取集合的取出对象。因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。
3）三个方法：
next();//取出下一个元素
remove();//移除
注：在迭代时循环中next调用一次，就要hasNext判断一次
如：
ArrayList a=newArrayList();//创建一个集合
Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。
//第一种打印方式：
for(Iterator iter = a.iterator();iter.hasNext();){
System.out.println(iter.next());
}
//第二种打印方式：
Iterator iter = a.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
} 迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object，所以要记得类型转换。
3.List类
1.list的组成结构
List：元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
2.List的特有方法：凡是可以操作角标的方法都是该体系特有的方法。
1）增
boolean add(index,element);//指定位置添加元素
Boolean addAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素
2）删
Boolean remove(index);//删除指定位置的元素
3）改
set(index,element);//修改指定位置的元素。
4）查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5）其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1
注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。
3.ListIterator 是List集合特有的迭代器，是Iterator的子接口，对Iterator进行了扩展。
ListIterator特有的方法：
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
4.Vector中的枚举Enumeration
1、枚举就是Vector特有的取出方式
2、发现枚举和迭代器很像。
3、其实枚举和迭代是一样的，因为枚举的名称以及方法的名称都过长，所以被迭代器取代了
它底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
特有方法：
1、增
addFirst();
addLast();
2、获取
//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后，出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
LinkedList代码示例：
package collection;
import java.util.LinkedList;
/**
* 使用LinkedList模拟一个堆栈或者队列数据结构。
* 堆栈：先进后出 如同一个杯子。
* 队列：先进先出 FIFO 如同一个水管。
* @author songwenju
*
*/
public class LinkedListDemo {
//模拟栈
public static void stack(LinkedList<String> list){
while (!list.isEmpty()) {
System.out.println(list.removeFirst());
}
}
//模拟队列
public static void queue(LinkedList<String> list){
while (!list.isEmpty()) {
System.out.println(list.removeLast());
}
}
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<String>();
list.addFirst("java01");
list.addFirst("java02");
list.addFirst("java03");
list.addFirst("java04");
list.addFirst("java05");
//堆栈输出
//stack(list);
//队列输出
queue(list);
}
}
1.Set的组成结构
Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。
Set集合的功能和Collection是一致的。
2.HashSet
1）HashSet：线程不安全，存取速度快。
2）可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。
如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
3）HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
代码示例：
package collection;
import java.util.HashSet;
/**
* 往hashSet集合中存入自定义对象
* 姓名和年龄相同为同一个人，重复元素。去除重复元素
* 思路：
* 1、对人描述，将人的一些属性等封装进对象
* 2、定义一个HashSet容器，存储人对象
* 3、取出
* @author songwenju
*
*/
class Person{
private String name;
private int age;
public Person() {}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//以下hashCode和equals是由eclipse生成的代码。
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof Person)) {
return false;
}
Person other = (Person) obj;
if (age != other.age) {
return false;
}
if (name == null) {
if (other.name != null) {
return false;
}
} else if (!name.equals(other.name)) {
return false;
}
return true;
}
}
public class HashSetDemo {
public static void main(String[] args) {
HashSet<Person> h = new HashSet<Person>();
h.add(new Person("stu1", 10));
h.add(new Person("stu2", 6));
h.add(new Person("stu3", 30));
h.add(new Person("stu1", 10));
h.add(new Person("stu4", 10));
for (Person p : h) {
System.out.println(p.getName()+"-->"+p.getAge());
}
}
}
分析：重复元素去重。
1） 底层的数据结构为二叉树结构（红黑树结构）
2）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。
3） java中的很多类都具备比较性，其实就是实现了Comparable接口。
4）排序时，当主要条件相同时，按次要条件排序。
5）保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
6）Tree排序的两种方式
1、方式一，自然排序：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。
代码示例：
package collection;
import java.util.TreeSet;
/**
* 自然排序
* @author songwenju
*
*/
//这里要实现Compare接口，否则会报collection.Student cannot be cast to java.lang.Comparable错误
class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//覆写compareTo
@Override
public int compareTo(Student student) {
if (this.age == student.age) {
return this.name.compareTo(student.name);
}
return this.age - student.age;
}
}
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<Student> t = new TreeSet<Student>();
t.add(new Student("stu1", 12));
t.add(new Student("stusj", 2));
t.add(new Student("stu1swj", 12));
t.add(new Student("stu6ds", 12));
t.add(new Student("stu", 22));
for (Student p : t) {
System.out.println(p.getName()+"-->"+p.getAge());
}
}
}
2、方式二，比较器：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
当两种排序都存在时，以比较器为主。
代码示例：
package collection;
import java.util.Comparator;
import java.util.TreeSet;
/**
* 往TreeSet集合中存储自定义对象学生。
* 想按照学生的年龄进行排序。
* @author songwenju
*
*/
//这里要实现Compare接口，否则会报collection.Student cannot be cast to java.lang.Comparable错误
class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//覆写compareTo
@Override
public int compareTo(Student student) {
if (this.age == student.age) {
return this.name.compareTo(student.name);
}
return this.age - student.age;
}
}
//定义一个比较器
class LenCompare implements Comparator<Student>{
@Override
public int compare(Student s1, Student s2) {
int num = new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length()));
if (num == 0) {
return new Integer(s1.getAge()).compareTo(s2.getAge());
}
return 0;
}
}
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<Student> t = new TreeSet<Student>();
t.add(new Student("stu1", 12));
t.add(new Student("stu1", 12));
t.add(new Student("stusj", 2));
t.add(new Student("stu1swj", 12));
t.add(new Student("stu6ds", 12));
t.add(new Student("stu", 22));
for (Student p : t) {
System.out.println(p.getName()+"-->"+p.getAge());
}
}
}
5.Map集合
1. Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）
2.该集合存储键值对，一对一对往里存。要保证键的唯一性。
3.Map的组成结构
Map
|--Hashtable：底层是哈希表数据结构，不可以存入null键 null值。该集合是线程同步的。JDK1.0，效率低。
|--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
4.Map集合常用方法
1、添加
V put(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。
void putAll(Map <? extends K,? extends V> m);//添加一个集合
2、删除
clear();//清空
V remove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
V get(Object key);//通过键获取对应的值
size();//获取集合的长度
Collection<V>value();//获取Map集合中所以得值，返回一个Collection集合
还有两个取出方法，接下来会逐个讲解：
Set<Map.Entry<K,V>> entrySet();
Set<K> keySet();
注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。
5.Map集合的两种取出方式Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。
1、Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。先通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。
代码示例：
package collection;
import java.util.HashMap;
/**
* 对Map进行遍历输出
* @author songwenju
*
*/
public class MapDemo {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<String, String>();
map.put("河南", "郑州");
map.put("河北", "石家庄");
map.put("湖南", "长沙");
map.put("湖北", "武汉");
//对keyset进行遍历，得到每一个key再得到对于的value。
for (String k : map.keySet()) {
System.out.print(k + "-->");
System.out.println(map.get(k));
}
}
}
2、Set<Map.Entry<K,V>> entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry 其实，Entry也是一个接口，它是Map接口中的一个内部接口。关系如下：
interface Map {
public static interface Entry{
public abstract Object getKey();
public abstract Object getValue();
}
}
package collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* 对Map进行遍历输出
* @author songwenju
*
*/
public class MapEntryDemo {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<String, String>();
map.put("河南", "郑州");
map.put("河北", "石家庄");
map.put("湖南", "长沙");
map.put("湖北", "武汉");
/*
* 用for each实现
*/
//对keyset进行遍历，得到每一个key再得到对于的value。
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Entry<String, String> k : entries) {
System.out.print(k.getKey() + "-->");
System.out.println(k.getValue());
}
System.out.println("----------------------");
/*
* 用Iterator迭代实现
*/
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> me = it.next();
System.out.print(me.getKey() + "-->");
System.out.println(me.getValue());
}
}
}
5.Entry是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？
原因：a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。
6.当量数据之间存在着映射关系的时候，就应该想到使用Map集合。
‘如： 获取该字符串中的字母出现的次数，如："sjokafjoilnvoaxllvkasjdfns"；希望打印的结果是：a(3)c(0).....
通过结果发现，每个字母都有对应的次数，说明字母和次数之间有映射关系。
代码示例：
package collection;
import java.util.Map.Entry;
import java.util.TreeMap;
/**
* 需求： 获取该字符串中的字母出现的次数，如："sjokafjoilnvoaxllvkasjdfns"；希望打印的结果是：a(3)c(1).....
* 思路：
* 1、将字符串转换为字符数组
* 2、定义一个TreeMap集合，用于存储字母和字母出现的次数
* 3、用数组去遍历集合，如果集合中有该字母则次数加1，如果集合中没有则存入
* 4、将TreeMap集合中的元素转换为字符串
* @author songwenju
*
*/
public class CharCount {
public static void main(String[] args) {
String s = "agk;sjaksd;gsa";
System.out.println("s中各字母出现的个数："+charCount(s));
}
public static String charCount(String str) {
char[] chs = str.toCharArray();//转化为字符数组
//定义一个TreeMap集合，因为TreeMap集合会给键自动排序
TreeMap<Character, Integer> map = new TreeMap<Character, Integer>();
int count = 0;//定义计数变量
for (int i = 0; i < chs.length; i++) {
if (!(chs[i]>='a' && chs[i]<= 'z'||chs[i]>='A' && chs[i]<= 'Z')) {
continue;//如果字符串中非字母，则不计数
}else {
Integer value = map.get(chs[i]);//获取集合中的值
if (value != null) {//如果集合中没有该字母，则存入
count = value;
}
count++;
map.put(chs[i], count);
count = 0;
}
}
StringBuilder sBuilder = new StringBuilder();
for (Entry<Character, Integer> c : map.entrySet()) {
sBuilder.append(c.getKey()+"("+c.getValue()+")");
}
return sBuilder.toString();
}
}
运行结果：
------- android培训、java培训、期待与您交流！ ----------
扫一扫
600
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
