基本数据类型对象包装类
为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为，丰富了
该对象的操作。用于描述该对象的类就称为基本数据类型的对象包装类。
基本类型（对应对象）：byte-Byte、short-Short、int-Integer、long-Long、
float-Float、double-Double、char-Character、boolean-Boolean。
该包装对象主要用于基本类型字符串之间的转换
例：static int parseInt(String s) //将字符串参数作为有符号的十进制整数进行解析。
基本类型---->字符串
1.基本数据类型+“”；
2.用String类中的静态方法valueOf(基本数据类型)；
3.用Integer的静态方法valueOf();
字符串---->基本类型
1.使用包装类中的方法 parseInt()、parseLong()、parseDouble()、
Boolean.parseBoolean("booleanstring")等；
只有Character没有parse方法；
2.如果字符串被Integer进行了对象的封装，可以使用另一个非静态的方法
intValue()；
整数具备不同的进制体现：
十进制---->其他进制
十进制---->二进制 Integer.toBinaryString();
十进制---->八进制 Integer.toOctalString();
十进制---->十六进制 Integer.toHexString();
十进制---->任意进制 Integer.toString(int i,int radix);//返回用第二个参数指定基
数表示的第一个参数的字符串表示形式
其他进制---->十进制
parseInt(String s, int radix);//使用第二个参数指定的基数，将字符串参数解析为有
符号的整数。
JDK1.5自动装箱拆箱
Integer i=4;//i=new Integer(4);自动装箱，简化书写
i=i+6;//i=new Integer(i.intValue()+6);自动拆箱，如果i=null，则出现异常
Integer a=new Integer(127);
Integer b=new Integer(127);
System.out.println(a==b);//false
System.out.println(a.equals(b));//true
Integer x=127;//jdk1.5以后，自动装箱，如果装箱的是一个字节，
Integer y=127;//那么该数据会被共享，不会重新开辟控件
System.out.println(x==y);//true,若x、y>127，则false
System.out.println(x.equals(y));//true
基本数据类型对象包装类练习：
package cn.itcast.p2.wrapper.demo;
import java.util.Arrays;
/*
* 对一个字符串中的数值进行从小到大的排序
* "20 78 9 -7 88 36 29"
* 思路：
* 1.排序
* 2.如何获取到字符串中需要排序的数值？
* 这个字符串中都是使用空格来对数值进行分割的，所以
* 就想到用字符串对象的切割方法将大串变成多个小串；
* 3.数值最终变成了小字符串，需要转换为int数值；
* 字符串-->基本类型，使用包装类
*/
public class WrapperTest {
private static final String SPACE_SEPARATOR=" ";
/**
* @param args
*/
public static void main(String[] args) {
String numStr = "20 78 9 -7 88 36 29";
System.out.println(numStr);
numStr = sortStringNumber(numStr);
System.out.println(numStr);
}
public static String sortStringNumber(String numStr) {
// 1.将字符串变成数组
String[] str_arr = stringToArray(numStr);
// 2.将字符串数组变成int数组
int[] num_arr = toIntArray(str_arr);
// 3.对int数组排序
mySortArray(num_arr);
// 4.将排序后的int数组变成字符串
String temp = arrayToString(num_arr);
return temp;
}
public static String arrayToString(int[] num_arr) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < num_arr.length; i++) {
if (i != num_arr.length - 1)
sb.append(num_arr[i] + SPACE_SEPARATOR);
else
sb.append(num_arr[i]);
}
return sb.toString();
}
public static void mySortArray(int[] num_arr) {
Arrays.sort(num_arr);
}
public static int[] toIntArray(String[] str_arr) {
int[] arr = new int[str_arr.length];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(str_arr[i]);
}
return arr;
}
public static String[] stringToArray(String numStr) {
String[] str_arr = numStr.split(SPACE_SEPARATOR);
return str_arr;
}
}
集合框架
集合类
StringBuffer、StringBuilder最终必须转成字符串才可以使用。
集合类的由来
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定，就使用集合容器进行存储。
特点：
1.用于存储对象的容器；
2.集合的长度是可变的；
3.集合中不可以存储基本数据类型值；
集合容器因为内部的数据结构不同，有多种具体容器。不断向上抽取，就形成了集合框架。框架的顶层是Collection接口。
Collection的常见功能：
1.添加
boolean add(Object e) //确保此 collection 包含指定的元素（可选操作）。
boolean addAll(Collection coll)//将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
2.删除
boolean remove(Object o)//从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection coll)//移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
void clear()//移除此 collection 中的所有元素（可选操作）。
3.判断
boolean contains(Object o)//如果此 collection 包含指定的元素，则返回 true。
boolean containsAll(Collection coll)//如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean isEmpty()//如果此 collection 不包含元素，则返回 true。
4.获取
int size();//返回此 collection 中的元素数。
Iterator<E> iterator();//返回在此 collection 的元素上进行迭代的迭代器。
该对象必须依赖于具体的容器，因为每一个容器的数据结构都不同。所以该迭代器对象是在容器内部进行实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器对象即可。也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
5.其他
boolean retainAll(Collection coll)//仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。 取交集
Object[] toArray();//返回包含此 collection 中所有元素的数组。
迭代器使用示例：
package cn.itcast.p3.collection.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo {
/**
* @param args
*/
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
System.out.println(coll);
// 使用Collection中的Iterator()方法,调用集合中的迭代器方法，是为了获取集合中的迭代器对象
// Iterator it=coll.iterator();
// while(it.hasNext()){
// System.out.println(it.next());
// }
for (Iterator it = coll.iterator(); it.hasNext();) {
System.out.println(it.next());
}
}
}
常用的子接口
List和Set
List特点
public interface List<E>extends Collection<E>
1.有序的 collection（也称为序列），存取顺序一致；
2.元素都有索引；
3.存储的元素允许重复；
Set特点
1.元素不能重复；
2.无序（可能有序）；
List特有的常见方法：
有一个共性特点：都可以操作角标。
1.添加
void add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。
boolean addAll(int index, Collection c) 将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
2.删除
Object remove(int index) 移除列表中指定位置的元素（可选操作）。
3.修改
Object set(int index, Object element) 用指定元素替换列表中指定位置的元素（可选操作）。
4.获取
Object get(int index) 返回列表中指定位置的元素。
※List特有的取出方式。
int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
List subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图
List集合可以完成对元素的增删查改。
List使用示例：
package cn.itcast.p4.collection.demo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
List list = new ArrayList();
// show(list);
list.add("abc1");
list.add("abc2");
list.add("abc3");
ListIterator it = list.listIterator();// 获取列表迭代器对象
// 它可以实现在迭代过程中完成对元素的增产查改
// 注意：只有List集合具备该迭代功能
while (it.hasNext()) {
Object obj = it.next();
if (obj.equals("abc2")) {
it.set("abc9");
}
}
// System.out.println("hasNext:"+it.hasNext());
// System.out.println("hasPrevious:"+it.hasPrevious());
while (it.hasPrevious()) {
System.out.println("previous:" + it.previous());
}
System.out.println(list);
/*
// Iterator it = list.iterator();
while (it.hasNext()) {
Object obj = it.next();// java.util.ConcurrentModificationException
// 迭代器迭代过程中，集合产生了操作。解决：使用迭代方法 //在迭代过程中，不要使用集合操作元素，容易出现异常
// 可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作
if (obj.equals("abc2")) {
list.add("abc9");
} else
System.out.println("next:" + obj);
}
System.out.println(list);
*/
}
List：
|--Vector 内部是数组数据结构，是同步的（效率低）。增删、查询都很慢。
|--ArrayList 内阻是数组数据结构，是不同步的（效率高）。替代了Vector。查询速度快。
|--LinkedList 内部是链表数据结构，是不同步的。增删速度快。
Vector:
public interface Enumeration<E>
此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。
LinkedList：
void addFirst(E e) 将指定元素插入此列表的开头。
void addLast(E e) 将指定元素添加到此列表的结尾。
boolean offerFirst(E e) 在此列表的开头插入指定的元素。
boolean offerLast(E e) 在此列表末尾插入指定的元素。
※
E removeFirst() 移除并返回此列表的第一个元素。 如果没有元素则抛出异常（NoSuchElementException）。
E removeLast() 移除并返回此列表的最后一个元素。 如果没有元素则抛出异常（NoSuchElementException）。
E pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E getFirst() 获取但不移除此列表的第一个元素。 如果没有元素则抛出异常（NoSuchElementException）。
E getLast() 获取但不移除此列表的最后一个元素。如果没有元素则抛出异常（NoSuchElementException）。
E peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
LinkedList练习示例：
package cn.itcast.p2.linkedlist.test;
/*
* 请使用LinkedList来模拟一个堆栈或者队列数据结构
* 堆栈：先进后出（FILO）
*
* 队列：先进先出（FIFO）
*
* 描述这样一个容器，给使用者提供一个容器对象，完成这两种结构。
*/
public class LinkdeTest {
/**
* @param args
*/
public static void main(String[] args) {
DuiLie dl=new DuiLie();
dl.myAdd("abc1");
dl.myAdd("abc2");
dl.myAdd("abc3");
dl.myAdd("abc4");
while(!dl.isNull()){
System.out.println(dl.myGet());
}
}
}
package cn.itcast.p2.linkedlist.test;
import java.util.LinkedList;
public class DuiLie{
private LinkedList link;
DuiLie(){
link=new LinkedList();
}
/**
* 队列的添加元素的方法
* @param obj
*/
public void myAdd(Object obj){
link.addLast(obj);
}
public Object myGet(){
return link.removeFirst();
}
public boolean isNull(){
return link.isEmpty();
}
}
ArrayList练习示例：
package cn.itcast.p.bean;
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package cn.itcast.p3.arraylist.test;
import java.util.ArrayList;
import java.util.Iterator;
import cn.itcast.p.bean.Person;
public class ArrayListTest {
/**
* @param args
*/
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add(new Person("lisi1", 21));
al.add(new Person("lisi2", 22));
al.add(new Person("lisi3", 23));
al.add(new Person("lisi4", 24));
Iterator it = al.iterator();
while (it.hasNext()) {
// System.out.println(((Person) it.next()).getName()+"::"+((Person)
// it.next()).getAge());//会出现错误
Person p = (Person) it.next();
System.out.println(p.getName() + "::" + p.getAge());
}
}
}
ArrayList练习：
package cn.itcast.p3.arraylist.test;
import java.util.ArrayList;
import java.util.Iterator;
import cn.itcast.p.bean.Person;
/*
* 定义功能去除ArrayList中的重复元素
*/
public class ArrayListTest2 {
/**
* @param args
*/
public static void main(String[] args) {
// singleDemo();
ArrayList al = new ArrayList();
al.add(new Person("lisi1", 21));
al.add(new Person("lisi2", 22));
al.add(new Person("lisi3", 23));
al.add(new Person("lisi4", 24));
al.add(new Person("lisi2", 22));
al.add(new Person("lisi3", 23));
System.out.println(al);
al = getSingleElement(al);
System.out.println(al);
}
public static ArrayList getSingleElement_2(ArrayList al) {
// 1.定义一个临时容器
ArrayList temp = new ArrayList();
// 2.迭代al集合
Iterator it = al.iterator();
while (it.hasNext()) {
Object obj = it.next();
// 3.判断被迭代到的元素是否存在于临时容器中
if (!(temp.contains(obj))) {
temp.add(obj);
}
}
return temp;
}
/**
*
*/
private static void singleDemo() {
ArrayList al = new ArrayList();
al.add("abc1");
al.add("abc2");
al.add("abc2");
al.add("abc1");
al.add("abc");
System.out.println(al);
al = getSingleElement(al);
System.out.println(al);
}
public static ArrayList getSingleElement(ArrayList al) {
// 1.定义一个临时容器
ArrayList temp = new ArrayList();
// 2.迭代al集合
Iterator it = al.iterator();
while (it.hasNext()) {
Object obj = it.next();
// 3.判断被迭代到的元素是否存在于临时容器中
if (!(temp.contains(obj))) {
temp.add(obj);
}
}
return temp;
}
}
package cn.itcast.p.bean;
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
if(this==obj)
return true;
if(!(obj instanceof Person))
throw new ClassCastException("类型错误");
// System.out.println(this+"...equals..."+obj);
Person p = (Person) obj;
return this.name.equals(p.name) && this.age == p.age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+":"+age;
}
}
判断元素是否重复：
ArrayList使用equals，HashSet使用hashCode和equals
Set：元素不能重复，是无序的。
Set接口中的方法与Collection一致。
|--HashSet 内部数据结构是哈希表，是不同步的。
|--TreeSet
哈希表确定元素是否相同
1.判断的是两个元素的哈希值是否相同；
如果相同，再判断两个对象的内容是否相同。
2.判断哈希值相同，其实判断的是对象的hashCode方法；
判断内容相同，用的是equals方法。
注意：如果哈希值不同，不需要判断equals方法。
HashSet示例：
package cn.itcast.p4.hashset.test;
import java.util.HashSet;
import java.util.Iterator;
import cn.itcast.p.bean.Person;
/*
* 在hashSet集合中存储Person对象，如果姓名和年龄相同，视为同一个人，视为相同元素
*/
public class HashSetTest {
/**
* @param args
*/
public static void main(String[] args) {
HashSet hs=new HashSet();
hs.add(new Person("lisi4",24));
hs.add(new Person("lisi7",27));
hs.add(new Person("lisi1",21));
hs.add(new Person("lisi9",29));
hs.add(new Person("lisi7",27));//对象地址不同，系统认为是不同的对象（Object的equals比较地址）
//需重写hashCode和equals
/*
* HashSet集合数据结构是哈希表，所以存储元素的时候，
* 使用的元素的hashCode方法来确定位置，如果位置相同，再通过元素的equals来确定是否相同
*
*/
Iterator it=hs.iterator();
while(it.hasNext()){
Person p=(Person)it.next();
System.out.println(p.getName()+"..."+p.getAge());
}
}
}
package cn.itcast.p.bean;
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
// System.out.println(this+"...hashCode");
return name.hashCode() + age*39;//age*39 保证哈希值的唯一，避免使用equals进行比较
}
@Override
public boolean equals(Object obj) {
if(this==obj)
return true;
if(!(obj instanceof Person))
throw new ClassCastException("类型错误");
// System.out.println(this+"...equals..."+obj);
Person p = (Person) obj;
return this.name.equals(p.name) && this.age == p.age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+":"+age;
}
}
LinkedHashSet：具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
HashSet hs=new LinkedHashSet();
TreeSet：
基于 TreeMap 的 NavigableSet 实现。
可以对Set集合中的元素，使用自然顺序对元素进行排序。
判断元素唯一性的方式，就是根据比较方法CompareTo的返回结果是否是0。是0，则认为是相同元素，不存储。
TreeSet集合对元素进行排序的方式一：
让元素自身具备比较功能，元素需要实现Comparable接口，覆盖CompareTo方法；
如果不按照对象中具备的自然顺序进行排序，如果对象中不具备自然顺序，可以使用TreeSet集合的第二种排序方式：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。将该类对象作为参数，传递给TreeSet集合的构造函数。
示例：
package cn.itcast.p5.treeset.demo;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.p.bean.Person;
public class TreeSetDemo {
public static void main(String[] args) {
// demo1();
/*
* 以Preson对象的年龄，进行从小到大的排序
*/
TreeSet ts=new TreeSet(new ComparatorByName());//不使用默认比较方式，则定义比较器
ts.add(new Person("zhangsan",29));
ts.add(new Person("wangwu",23));
ts.add(new Person("lisi",21));
ts.add(new Person("zhouqi",29));
ts.add(new Person("zhaoliu",25));
Iterator it=ts.iterator();
while(it.hasNext()){
Person p=(Person)it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
}
package cn.itcast.p5.treeset.demo;
import java.util.Comparator;
import cn.itcast.p.bean.Person;
/**
* 创建以Person对象年龄进行从小到大的排序
* @author chenchong
*
*/
public class ComparatorByName implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Person p1=(Person)o1;
Person p2=(Person)o2;
int temp=p1.getName().compareTo(p2.getName());
return temp==0?p1.getAge()-p2.getAge():temp;
}
}
TreeSet练习：
package cn.itcast.p5.treeset.test;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.p5.comparator.ComparatorByLength;
/*
* 对字符串进行按长度排序
*/
public class TreeSetTest {
/**
* @param args
*/
public static void main(String[] args) {
TreeSet ts = new TreeSet(new ComparatorByLength());
ts.add("aaaaa");
ts.add("zz");
ts.add("nbaq");
ts.add("cba");
ts.add("abc");
Iterator it = ts.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
package cn.itcast.p5.comparator;
import java.util.Comparator;
public class ComparatorByLength implements Comparator {
@Override
public int compare(Object o1, Object o2) {
String s1=(String)o1;
String s2=(String)o2;
int temp=s1.length()-s2.length();
return temp==0?s1.compareTo(s2):temp;//在长度相同时，按元素排序
}
}