包装类
基本数据类型使用起来非常方便,但是没有对应的方法来操作这些基本类型的数据。
可以使用一个类,把基本类型的数据装起来,在类中定义一些方法,这个类叫做包装类。
我们可以使用类中的方法来操作这些基本类型的数据。
基本类型 | 包装类(引用类型,都位于java.lang包下) |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
装箱与拆箱(以Integer类为例)
装箱: 把基本类型的数据,包装到包装类中(基本类型的数据 -> 包装类)
1.构造方法:
Integer(int value)
【构造一个新分配的Integer对象,它表示指定的int值】
Integer(String s)
【构造一个新分配的Integer对象,它表示String参数所指示的int值】
【传递的字符串必须是基本类型的字符串】
2.静态方法:
static Integer valueOf(int i)
【返回一个表示指定的int值的Integer对象】
static Integer valueOf(String s)
【返回保存指定的String的值的Integer对象】
拆箱: 在包装类中取出基本类型的数据(包装类 -> 基本类型的数据)
成员方法:
int intValue()
【以int类型返回该Integer的值】
public class Demo01Integer {
public static void main(String[] args) {
//装箱
//构造方法
Integer in1 = new Integer(1);
System.out.println(in1);//1
Integer in2 = new Integer("1");
System.out.println(in2);//1
//静态方法
Integer ii1 = Integer.valueOf(1);
System.out.println(ii1);//1
Integer ii2 = Integer.valueOf("1");
System.out.println(ii2);//1
//拆箱
int i = in1.intValue();
System.out.println(i);//1
}
}
自动装箱与自动拆箱
基本类型的数据和包装类之间可以自动的相互转换。(JDK1.5+)
public class Demo02Integer {
public static void main(String[] args) {
/*
* 自动装箱:直接把int类型的数据赋值包装类
* Integer in = 1;相当于Integer in = new Integer(1);
*/
Integer in = 1;
/*
* 自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本类型数据,再进行计算
* in + 2相当于in.intValue() + 2
* in = in.intValue + 2又是一个自动装箱
*/
in = in + 2;
}
}
基本类型与字符串之间的转换
基本类型 -> 字符串(String)
1.基本类型的值+""(最简单,常用)
2.包装类的静态方法toString(参数)【不是Object类的toString方法,是方法重载】
static String toString(int i)
【返回一个表示指定整数的String对象】
3.String类的静态方法valueOf(参数)
static String valueOf(int i)
【返回int参数的字符串表示形式】
字符串(String)-> 基本类型
使用包装类的静态方法parseXxx("字符串")
Integer类:static int parseInt(String s)
public class Demo03 {
public static void main(String[] args) {
//基本类型->字符串
int i1 = 100;
String s1 = i1 + "";
System.out.println(s1+"200");//100200
String s2 = Integer.toString(100);
System.out.println(s2+"200");//100200
String s3 = String.valueOf(100);
System.out.println(s3+"200");//100200
//字符串 -> 基本类型
int i2 = Integer.parseInt(s1);
System.out.println(i2+200);//300
}
}
Collection集合
集合: 集合是Java中提供的一种容器,可以用来存储多个数据
数组和集合的区别:
1.数组的长度是固定的,集合的长度是可变的。
2.数组中存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象,而且对象的的类型可以不一致。在开发中一般当对象多的时候,使用集合进行存储。
Collection常用方法
java.util.Collection是所有单列集合的父接口,因此在Collection中定义了单列集合(List和Set)通用的一些方法,这些方法可用于操作所有的单列集合。
1.public boolean add(E e)
【把给定的对象添加到当前集合中】
2.public void clear()
【清空集合中所有的元素】
3.public boolean remove(E e)
【把给定的对象在当前集合中删除】
4.public boolean contains(E e)
【判断当前集合中是否包含给定的对象】
5.public boolean isEmpty()
【判断当前集合是否为空】
6.public int size()
【返回集合中元素的个数】
7.public Object[] toArray()
【把集合中的元素存储到数组中】
Iterator迭代器
迭代: Collection集合元素的通用获取方式,在取元素之前要先判断集合中有没有元素。如果有,就把这个元素取出来,继续判断,如果还有就继续再取出来。一直把集合中的所有元素全部取出。这种取出方式,专业术语称为迭代。
java.util.Iterator接口:迭代器(对集合进行遍历)
Iterator接口的常用方法
1.public E next()
【返回迭代的下一个元素】
【取出下一个元素,将指针向后移动一位】
【没有元素,若取出元素或抛出NoSearchElementException异常】
2.public boolean hasNext()
【如果仍有元素可以迭代,返回true】
Iterator是一个接口,我们无法直接使用,需要使用Iterator接口实现类对象,获取实现类的方式比较特殊。
Collection接口中有一个方法iterator(),这个方法返回的就是迭代器的实现类对象。
Iterator<E> iterator()
【返回在此Collection的元素上进行迭代的迭代器】
【迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型】
迭代器的使用步骤:
1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
2.使用Iterator接口中的hasNext()方法判断还有没有下一个元素
3.使用Iterator接口中的next()方法取出集合中的下一个元素
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo04Iterator {
public static void main(String[] args) {
//创建一个集合对象(多态)
Collection<String> coll = new ArrayList<String>();
//向集合中添加元素
coll.add("1");
coll.add("2");
coll.add("3");
//使用集合中的iterator方法获取迭代器的实现类对象,使用Iterator接口接收(多态)
Iterator it = coll.iterator();
//使用迭代器取出元素是一个重复的过程,优化
while(it.hasNext()) {
Object s = it.next();
System.out.println(s);
}
//
// //使用Iterator接口中的hasNext()方法判断有没有下一个元素
// boolean a = it.hasNext();
// System.out.println(a);
// //使用Iterator接口中的next()方法取出下一个元素
// Object s = it.next();
// System.out.println(s);
//
// boolean a1 = it.hasNext();
// System.out.println(a1);
// Object s1 = it.next();
// System.out.println(s1);
}
}
增强for循环(JDK1.5+)
增强for循环,底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写。
Collection<E> extends Iterable<E>
【所有单列集合都可以使用增强for】
public interface Iterable<T>
【实现这个接口允许对象成为“foreach”语句的目标】
增强for循环:用来遍历集合和数组。
for(集合/数组的数据类型 变量名:集合名/数组名){
System.out.println(变量名);
}
import java.util.ArrayList;
public class Demo05For {
public static void main(String[] args) {
//使用增强for遍历数组
int[] array = {1,2,3,4,5};
for(int i : array) {
System.out.print(i+"*");//1*2*3*4*5*
}
System.out.println();
//使用增强for遍历集合
ArrayList<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for(String s : list) {
System.out.print(s+"*");//aaa*bbb*ccc*
}
}
}
泛型
泛型:一种未知的数据类型,当我们不知道使用什么数据类型的时候,可以使用泛型。
泛型也可以看作是一个变量用来接收数据。
E e: Element(元素)
T t: Type(类型)
创建集合对象,不使用泛型:
1.好处
集合不使用泛型,默认就是Object类型,可以存储任意类型的数据。
2.弊端
不安全会引发异常
【ClassCastException:类型转换异常】
创建集合对象,使用泛型:
1.好处
避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型。
把运行期异常(代码运行之后会抛出的异常),提升到了编译期。
2.弊端
泛型是什么类型就只能存储什么类型的数据。
泛型的定义和使用
定义和使用含有泛型的类:
修饰符 class 类名<代表泛型的变量>{
}
public class Demo06Generic {
public static void main(String[] args) {
//不写泛型,默认为Object
GenericClass gc1 = new GenericClass();
gc1.setName("一");
Object g1 = gc1.getName();
System.out.println(g1);//一
//创建GenericClass对象,使用Integer类型
GenericClass<Integer> gc2 = new GenericClass<Integer>();
gc2.setName(1);
Integer g2 = gc2.getName();
System.out.println(g2);//1
//创建GenericClass对象,使用String类型
GenericClass<String> gc3 = new GenericClass<String>();
gc3.setName("三");
String g3 = gc3.getName();
System.out.println(g3);//三
}
}
public class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
定义和使用含有泛型的方法
【泛型定义在方法的修饰符和返回值类型之间】
修饰符 <泛型> 返回值类型 方法名称(参数列表(使用泛型)){
方法体
}
含有泛型的方法在方法调用的时候确定泛型的数据类型。
传递什么类型的参数,泛型就是什么类型。
public class Demo07GenericMethod {
public static void main(String[] args) {
//创建GenricMethod对象
GenericMethod gm = new GenericMethod();
gm.method1(1);//1
gm.method1("一");//一
gm.method1(true);//true
GenericMethod.method2("静态方法,直接使用类名调用");//静态方法,直接使用类名调用
GenericMethod.method2(2);//2
}
}
public class GenericMethod {
//定义一个使用泛型的方法
public <M> void method1(M m) {
System.out.println(m);
}
//定义一个使用泛型的静态方法
public static <M> void method2(M m){
System.out.println(m);
}
}
定义和使用含有泛型的接口
修饰符 interface 接口名<泛型>{}
【定义接口的实现类,实现接口时指定接口的泛型】
【接口使用什么泛型,实现类就是用什么泛型,创建对象时确定泛型的类型】
public class Demo08GenericInterface {
public static void main(String[] args) {
//创建GenericInterfaceImpl1对象
GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
gi1.method("字符串");//字符串
//创建一个GenericInterfaceImpl2对象
GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<Integer>();
gi2.method(2);//2
}
}
public interface GenericInterface<I> {
public abstract void method(I i);
}
public class GenericInterfaceImpl1 implements GenericInterface<String>{
@Override
public void method(String i) {
// TODO Auto-generated method stub
System.out.println(i);
}
}
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
@Override
public void method(I i) {
// TODO Auto-generated method stub
System.out.println(i);
}
}
泛型通配符
?
【代表任意的数据类型】
【不能创建对象使用,只能作为方法的参数使用】
import java.util.ArrayList;
import java.util.Iterator;
public class Demo09Generic {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<Integer>();
list1.add(1);
ArrayList<String> list2 = new ArrayList<String>();
list2.add("一");
printList(list1);//1
printList(list2);//一
// ArrayList<?> list3 = new ArrayList<?>(); 错误写法
}
public static void printList(ArrayList<?> list) {
Iterator it = list.iterator();//迭代器
while(it.hasNext()) {
Object i = it.next();
System.out.println(i);
}
}
}
1.泛型的上限限定
? extends E
【代表使用的泛型只能是E类型的子类或E本身】
2.泛型的下限限定
? super E
【代表使用的泛型只能是E类型的父类或E本身】