文章目录
StringBuilder类
String类:
字符串常量,创建后不可更改,字符串的底层是一个被final修饰的数组
private final byte[] value;
StringBuilder类:
字符串缓冲区,可以提高字符串的操作效率(看成一个长度可以变化的字符串)
底层也是一个数组,但是没有被final修饰,可以改变长度
byte[] value = new byte[16];
StringBuilder在内存中始终是一个数组,占用的空间少,效率高,如果超出了StringBuilder的容量,会自动的扩容
StringBuilder类的构造方法及常用方法
public class Demo01StringBuilder {
public static void main(String[] args) {
//空参构造方法
StringBuilder bu1 = new StringBuilder();
System.out.println("bu1:"+bu1);
//带字符串的构造方法
StringBuilder bu2 = new StringBuilder("abc");
System.out.println("bu2:"+bu2);
//StringBuilder的常用方法
//append方法返回的是this,即调用方法的对象bu1 this==bu1
StringBuilder bu3 = bu1.append("efg");//把部的地址赋值给了bu3
System.out.println(bu1);
System.out.println(bu3);
System.out.println(bu1==bu3);//地址相同
//使用append方法无需接收返回值,可链式编程
bu1.append("hij").append(1).append(true).append(5.2).append('中');
System.out.println(bu1);
//toString方法:StringBuilder->String
String s = bu2.toString();
System.out.println(s);
}
}
集合Collection
集合框架
集合和数组的区别
- 存储的数据类型
数组可以存储基本类型,也可以存储引用类型
集合只能存储引用类型 - 存储的内容
数组只能存储一种类型的数据
集合可以存储不同类型(Object),但一般存储的是同一种类型 - 长度
数组不可变,集合可变
Colletion常用功能
import java.util.ArrayList;
import java.util.Collection;
/*
java.util.Collection接口:
是所有单列集合的最顶层的接口,里面定义了所有单列集合共性的方法
任意的单列集合都可以使用Collection接口中的方法
*/
public class Demo01Collection {
public static void main(String[] args) {
// 创建集合对象,可以使用多态
Collection<String> coll = new ArrayList<>();
System.out.println(coll);//重写了toString方法 []
// public boolean add(E e):把给定对象添加到当前集合中
coll.add("abc");
coll.add("efg");
System.out.println(coll);//[abc]
// public int size():返回集合中元素的个数
System.out.println("coll中元素个数:"+coll.size());
// public Object[] toArray();把结合中的元素,存储到数组中// public Object[] toArray();把结合中的元素,存储到数组中
Object[] array = coll.toArray();
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
// public boolean remove(E e):把给定对象再当前集合中删除,删除成果返回true
coll.remove("abc");
System.out.println(coll);//[efg]
// public boolean contains(E e):判断当前集合中是否包含给定的对象
System.out.println(coll.contains("efg"));//true
// public void clear():情况集合当中所有的元素
coll.clear();
System.out.println(coll);//[]
// public boolean isEmpty():判断当前集合是否为空
System.out.println(coll.isEmpty()); //true
}
}
Iterator迭代器
Iterator迭代器的使用方法
/*
java.util.Iterator接口:迭代器(对集合进行遍历)
有两个常用方法
boolean hasNext() 如果仍有元素可以迭代,则返回 true。
E next() 返回迭代的下一个元素。
Iterator迭代器是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊
Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象
Iterator<E> iterator() 返回在此collection的元素上进行迭代的迭代器
迭代器的使用步骤:
1. 使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
2. 使用Iterator接口中的方法hasNext判断还有没有下一个元素
3. 使用Iterator接口中的方法next取出集合中的下一个元素
*/
public class Demo02Iterator {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<>();
coll.add("abc");
coll.add("def");
coll.add("ghi");
// Iterator<E>接口也是有泛型的,泛型跟集合保持一致
Iterator<String > it = coll.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}
增强for
import java.util.ArrayList;
/*
增强for循环:底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写
是JDK1.5之后出现的新特性
Collection<E> extends Iterable<E>:所有的单列集合都可以使用增强for
public interface Iterable<T>实现这个接口允许对象成为 "foreach" 语句的目标。
增强for循环:用来遍历集合和数组
格式:
for(集合/数组的数据类型 变量名:集合名/数组名){
sout(变量名)
}
*/
public class Demo03ForEach {
public static void main(String[] args) {
demo01();
demo02();
}
// 使用增强for循环遍历集合
private static void demo02() {
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
for(String s:list){
System.out.println(s);
}
}
// 使用增强for循环遍历数组
private static void demo01() {
int[] arr = {1, 2, 3, 4, 5};
for(int i:arr){
System.out.println(i);
}
}
}
泛型
泛型是一种未知的数据类型,当我们不知道使用什么数据类型的时候,可以使用泛型
泛型也可以看成是一个变量,用来接收数据类型
E e:Element 元素
T t:Type 类型
ArrayList集合在定义的时候,不知道集合中都会存储什么类型的数据,所以使用泛型,创建对象的时候会确定泛型的类型,会把数据类型作为参数传递,赋值给泛型E
使用泛型的好处
import java.util.ArrayList;
import java.util.Iterator;
public class Demo01Generic {
public static void main(String[] args) {
// show01();
show02();
}
/*
创建集合对象,使用泛型
好处:
1.避免了类型转换的麻烦,存储的是什么类型,去除的就是什么类型
2.把运行期异常(代码运行之后会抛出的异常),提升到了编译器(写代码的时候会报错)
弊端:泛型是什么类型,就只能存储什么类型的工具
*/
private static void show02() {
ArrayList<String> list = new ArrayList<>();
list.add("abc");
// list.add(1);//编译的时候就直接报错
}
/*
创建集合对象,不使用泛型
好处:集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
弊端:不安全,会引发异常
*/
private static void show01() {
ArrayList list = new ArrayList();
list.add("abc");
list.add(1);
Iterator it = list.iterator();
while(it.hasNext()){
// 取出元素也是object类型
Object obj = it.next();
System.out.println(obj);
// 想要使用String类特有的方法length获取字符串的长度
//需要向下转型
String s = (String)obj;
System.out.println(s.length()); //抛出ClassCastException异常
}
}
}
定义和使用含有泛型的类
定义含有泛型的类
/*
定义一个含有泛型的类,模拟ArrayList集合
泛型是一个未知的数据类型,当我们不确定什么数据类型的时候,可以用泛型
泛型可以接收任意的数据类型,可以使用Integer,String,Student,...
创建对象的时候确定泛型的数据类型
*/
public class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
使用含有泛型的类
public class Demo02Generic {
public static void main(String[] args) {
// 不写泛型默认为Object类型
GenericClass gc = new GenericClass();
gc.setName("只能是字符串");
Object obj = gc.getName();
//创建GenericClass对象,泛型用Integer类型
GenericClass<Integer> gc2 = new GenericClass<>();
gc2.setName(1);
Integer name = gc2.getName();
System.out.println(name);
}
}
定义和使用含有泛型的方法
/*
定义含有泛型的方法:泛型定义在方法的修饰符和返回值之间
格式:
修饰符<泛型> 返回值类型 方法名(参数列表(使用泛型)){
方法体;
}
含有泛型的方法,在调用方法的时候确定泛型的数据类型
传递什么类型的参数,泛型就是什么类型
*/
public class GenericMethod {
// 定义一个含有泛型的方法
public <M> void method01(M m){
System.out.println(m);
}
//定义一个含有泛型的静态方法
public static <S> void method02(S s){
System.out.println(s);
}
}
/*
测试含有泛型的方法
*/
public class Demo03GenericMethod {
public static void main(String[] args) {
GenericMethod gm = new GenericMethod();
gm.method01(10);
gm.method01("abc");
gm.method01(true);
gm.method01(8.8);
gm.method02("静态方法,不建议创建对象使用");
GenericMethod.method02("静态方法");
}
}
泛型通配符
不知道使用什么类型接收时用<?>
import java.util.ArrayList;
import java.util.Iterator;
public class Demo05Generic {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
ArrayList<String> list2 = new ArrayList<>();
list2.add("a");
list2.add("b");
printArray(list1);
printArray(list2);
}
public static void printArray(ArrayList<?> list){
Iterator<?> it = list.iterator();
while(it.hasNext()){
Object o = it.next();
System.out.println(o);
}
}
}
泛型的上限限定和下限限定
斗地主案例
需求分析
代码
import java.util.ArrayList;
import java.util.Collections;
public class DouDiZhu {
public static void main(String[] args) {
// 定义一个存储54张牌的ArrayList集合
ArrayList<String> poker = new ArrayList<>();
// 定义两个数组,一个数组存储牌的花色,另一个存储序号
String[] colors = {"♠","♥","♣","♦"};
String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
// 先把大王小王存储到扑克集合中
poker.add("大王");
poker.add("小王");
// 循环嵌套遍历两个数组,组装52张牌
for(String number:numbers){
for(String color :colors){
// 把组装好的牌存到poker中
poker.add(color+number);
}
}
System.out.println(poker);
// 洗牌,使用collections中的工具类
//static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
Collections.shuffle(poker);
// 发牌
// 定义四个集合,存储玩家的牌和底牌
ArrayList<String> player01 = new ArrayList<>();
ArrayList<String> player02 = new ArrayList<>();
ArrayList<String> player03 = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>();
// 遍历poker集合
for (int i = 0; i < poker.size(); i++) {
String p = poker.get(i);
if(i>=51){
dipai.add(p);
}else if(i%3 == 0){
player01.add(p);
}else if(i%3 == 1){
player02.add(p);
}else if(i%3 == 2){
player03.add(p);
}
}
// 看牌
System.out.println("刘德华:"+player01);
System.out.println("周润发:"+player02);
System.out.println("周星驰:"+player03);
System.out.println("底牌:"+dipai);
}
}
结果