基本数据类型对象包装类
为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为,丰富了
该对象的操作。用于描述该对象的类就称为基本数据类型的对象包装类。
基本类型(对应对象):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;//在长度相同时,按元素排序
}
}