【day012】Java学习，坚持就是胜利！

最新推荐文章于 2024-05-18 16:42:38 发布

Only hand ripe

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量84

点赞数

文章标签：字符串 java 编程语言

本文链接：https://blog.csdn.net/qq_38592706/article/details/108539941

版权

一、StringBuilder的构造方法和append方法

在这里插入图片描述

package com.itheima.demo06.StringBuilder;

/*
    java.lang.StringBuilder类：字符串缓冲区，可以提高字符串的效率
    构造方法：
        - public StringBuilder(): 构造一个空的StringBuilder容器。
        - public StringBuilder(String str): 构造一个StringBuilder容器，并将字符串添加进去。
*/
public class Demo01StringBuilder {
    public static void main(String[] args) {
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:" + bu1); // bu1:

        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:" + bu2); // bu2:abc
    }
}

package com.itheima.demo06.StringBuilder;

/*
    StringBuilder类的成员方法：
        public StringBuilder append(...): 添加任意类型数据的字符串形式，并返回当前对象自身。
        参数：
            可以是任意的数据类型
*/
public class Demo02StringBuilder {
    public static void main(String[] args) {
        // 创建StringBuilder对象
        StringBuilder bu1 = new StringBuilder();
        // 使用append方法往StringBuilder中添加数据
        // append方法返回的是this，调用方法的对象bu1
        StringBuilder bu2 = bu1.append("abc");
        System.out.println(bu1); // abc
        System.out.println(bu2); // abc
        System.out.println(bu1==bu2); // true 两对象是同一个对象
        // 使用append方法无需接收返回值
        /*bu1.append("abc");
        bu1.append(1);
        bu1.append(true);
        bu1.append(8.8);
        bu1.append('中');
        System.out.println(bu1);*/ // abcabc1true8.8中
        /*
            链式编程：方法的返回值是一个对象，可以根据对象继续调用方法
        */
        System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase().toUpperCase()); // ABC
        bu1.append("abc").append(1).append(true).append(8.8).append('中');
        System.out.println(bu1); // abcabc1true8.8中
    }
}

二、System类&StringBuilder类

在这里插入图片描述

三、StringBuilder的toString方法

在这里插入图片描述

package com.itheima.demo06.StringBuilder;

/*
    StringBuilder和String可以相互转换：
        String -> StringBuilder:可以使用StringBuilder的构造方法
            StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
        StringBuilder -> String：可以使用StringBuilder中的toString方法
            public String toString(): 将当前StringBuilder对象转换为String对象。
*/
public class Demo03StringBuilder {
    public static void main(String[] args) {
        // String -> StringBuilder
        String str = "hello";
        System.out.println("str:"+str);
        StringBuilder bu = new StringBuilder(str);
        // 往StringBuilder中添加数据
        bu.append("world");
        System.out.println("bu:"+bu);

        // StringBuilder -> String
        String s = bu.toString();
        System.out.println("s:"+s);
    }
}
/*
str:hello
bu:helloworld
s:helloworld
*/

四、包装类的概念

在这里插入图片描述

五、包装类_装箱与拆箱

在这里插入图片描述

package com.itheima.demo07Integer;

/*
    装箱：把基本类型的数据，包装到包装类中（基本类型的数据 -> 包装类)
        构造方法：
            Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
            Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
                传递的字符串，必须是基本类型的字符串，否则会抛出异常“100”正确 “a”抛异常
         静态方法：
            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 重写了toString方法

        Integer in2 = new Integer("1");
        System.out.println(in2); // 1
        // 静态方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3); // 1

        Integer in4 = Integer.valueOf("a"); // NumberFormatException数字格式化异常
//        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);
    }
}

六、包装类_自动装箱与自动拆箱

在这里插入图片描述

七、包装类_基本类型与字符串类型之间的相互转换

在这里插入图片描述

package com.itheima.demo07Integer;
/*
    基本类型与字符串之间的转换
    基本类型-->字符串
        1. 基本类型数据的值+"" 最简单的方式(工作中常用)
        2. 使用包装类中的静态方法
            static String toString(int i) 返回一个表示指定整数的 String 对象。
        3. 使用String类中的静态方法
            static String valueOf(int i) 返回 int 参数的字符串表示形式。
    字符串-->基本类型
        使用包装类的静态方法parseXX("字符串")
            Integer类：static int parseInt(String s)
            Double类：static double parseDouble(String s)
            ...
*/
public class Demo03Integer {
    public static void main(String[] args) {
        // 基本类型-->字符串
        String s1 = 100+"";
        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 i = Integer.parseInt("100");
        System.out.println(i+200); // 300
//        int i2 = Integer.parseInt("a"); // NumberFormatException: For input string: "a" 数字格式化异常
//        System.out.println(i2);
    }
}

八、包装类总结

在这里插入图片描述

九、Collection集合概述

在这里插入图片描述

十、集合框架介绍

在这里插入图片描述

十一、Collection集合常用功能

package com.itheima.demo01.Collection;

import java.util.ArrayList;

/*
    java.util.Collection接口
        所有单列集合的最顶层的接口，里边定义了所有单列集合共性的方法
        任意的单列集合都可以使用Collection接口中的方法


    共性的方法：
        public boolean add(E e): 把给定的对象添加到当前集合中。
        public void clear(): 清空集合中所有的元素。
        public boolean remove(E e): 把给定的对象在当前集合中删除。
        public boolean contains(E e): 判断当前集合中是否包含给定的对象。
        public boolean isEmpty(): 判断当前集合是否为空。集合为空返回true，集合不为空返回false
        public int size(): 返回集合中元素的个数。
        public Object[] toArray(): 把集合中的元素，存储到数组中。
*/
public class Demo01Collection {
    public static void main(String[] args) {
        // 创建集合对象，可以使用多态
        ArrayList<String> coll = new ArrayList<>();
        System.out.println(coll);

        /*
            public boolean add(E e): 把给定的对象添加到当前集合中。
            返回值是一个boolean值，一般都返回true，所以可以不用接收
        */
        boolean b1 = coll.add("张三");
        System.out.println("b1:"+b1); // b1:true
        System.out.println(coll);

        coll.add("李四");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll); // [张三, 李四, 赵六, 田七]

        /*
            public boolean remove(E e): 把给定的对象在当前集合中删除。
            返回值是一个Boolean值，集合中存在元素，删除元素，返回true
                                   集合中不存在元素，删除失败，返回false
        */
        boolean b2 = coll.remove("赵六");
        System.out.println("b2:"+b2); //b2:true

        boolean b3 = coll.remove("赵四");
        System.out.println("b3:"+b3); //b3:false
        System.out.println(coll);

        /*
            public boolean contains(E e): 判断当前集合中是否包含给定的对象。
            包含返回true
            不包含返回false
        */
        boolean b4 = coll.contains("李四");
        System.out.println("b4:"+b4); // b4:true

        boolean b5 = coll.contains("赵四");
        System.out.println("b5:"+b5); // b5:false

        // public boolean isEmpty(): 判断当前集合是否为空。集合为空返回true，集合不为空返回false
        boolean b6 = coll.isEmpty();
        System.out.println("b6:"+b6); // b6:false

        // public int size(): 返回集合中元素的个数。
        int size = coll.size();
        System.out.println("size:"+size); // size:3

        //  public Object[] toArray(): 把集合中的元素，存储到数组中。
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        // public void clear(): 清空集合中所有的元素。但是不删除集合，集合还存在
        coll.clear();
        System.out.println(coll);
        System.out.println(coll.isEmpty());
    }
}
/*
[]
b1:true
[张三]
[张三, 李四, 赵六, 田七]
b2:true
b3:false
[张三, 李四, 田七]
b4:true
b5:false
b6:false
size:3
张三
李四
田七
[]
true
*/

十二、Collection集合

在这里插入图片描述

十三、Iterator接口介绍

在这里插入图片描述

package com.itheima.demo02.Iterator;
/*
    java.util.Iterator接口：迭代器(对几个进行遍历)
    有两个常用的方法：
        boolean hasNext() 如果仍有元素可以迭代，则返回true。
            判断集合中还有没有下一个元素，有就返回true，没有就返回false
        E next() 返回迭代的下一个元素。
     Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
     Collection接口中有一个方法，叫iterator(),这个方法返回的就是迭代器的实现类对象
        Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。
     迭代器的使用步骤（重点）：
        1. 使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)
        2. 使用Iterator接口中的方法hasNext判断还有没有下一个元素
        3. 使用Iterator接口中的方法next取出集合中的下一个元素
 */
public class Demo01Iterator {
}

十四、迭代器的代码实现

package com.itheima.demo02.Iterator;

import java.util.ArrayList;
import java.util.Iterator;


/*
    java.util.Iterator接口：迭代器(对几个进行遍历)
    有两个常用的方法：
        boolean hasNext() 如果仍有元素可以迭代，则返回true。
            判断集合中还有没有下一个元素，有就返回true，没有就返回false
        E next() 返回迭代的下一个元素。
     Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
     Collection接口中有一个方法，叫iterator(),这个方法返回的就是迭代器的实现类对象
        Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。
     迭代器的使用步骤（重点）：
        1. 使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)
        2. 使用Iterator接口中的方法hasNext判断还有没有下一个元素
        3. 使用Iterator接口中的方法next取出集合中的下一个元素
 */
public class Demo01Iterator {
    public static void main(String[] args) {
        // 创建一个集合对象
        ArrayList<String> coll = new ArrayList<>();
        // 往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");

        /*
             1. 使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)
             注意：
                    Iterator<E>接口特殊泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
        */
        // 多态       接口          实现类对象
        Iterator<String> it = coll.iterator();

        /*
            发现使用迭代器取出集合中元素的代码，是一个重复的过程
            所以我们可以使用循环优化
            不知道集合中有多少元素，使用while循环
            循环结束的条件,hasNext方法返回false
        */
        while (it.hasNext()) {
            String e = it.next();
            System.out.println(e);
        }
        System.out.println("====================");
        for (Iterator<String> it2 = coll.iterator(); it2.hasNext();) {
            String e = it2.next();
            System.out.println(e);
        }

       /* // 2. 使用Iterator接口中的方法hasNext判断还有没有下一个元素
        boolean b = it.hasNext();
        System.out.println(b); // true

        // 3. 使用Iterator接口中的方法next取出集合中的下一个元素
        String s = it.next();
        System.out.println(s); // 姚明

        b = it.hasNext();
        System.out.println(b);
        s = it.next();
        System.out.println(s);

        b = it.hasNext();
        System.out.println(b);
        s = it.next();
        System.out.println(s);

        b = it.hasNext();
        System.out.println(b);
        s = it.next();
        System.out.println(s);

        b = it.hasNext();
        System.out.println(b);
        s = it.next();
        System.out.println(s);

        b = it.hasNext();
        System.out.println(b); // 没有元素，返回false
        s = it.next(); // 没有元素，在取出元素会抛出NoSuchElementException没有元素异常
        System.out.println(s);*/

    }
}
/*
true
姚明
true
科比
true
麦迪
true
詹姆斯
true
艾弗森

姚明
科比
麦迪
詹姆斯
艾弗森
====================
姚明
科比
麦迪
詹姆斯
艾弗森
*/

十五、迭代器的实现原理

在这里插入图片描述

十六、增强for循环

在这里插入图片描述

package com.itheima.demo02.Iterator;

import java.util.ArrayList;

/*
    增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写
    是JDK1.5之后出现的新特性
    Collection<E>Extends Iterable<E>：所有的单列集合都可以使用增强for
    public interface Iterator<T>实现这个接口允许对象成为"foreach"语句的目标。

    增强for循环：用来遍历集合和数组

    格式：
        for(集合/数组的数据类型 变量名：集合名/数组名){
            sout(变量名);
        }
*/
public class Demo02Foreach {
    public static void main(String[] args) {
        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);
        }
    }
}
/*
1
2
3
4
5

aaa
bbb
ccc
ddd
*/

十七、泛型的概念

在这里插入图片描述

十八、使用泛型的好处

在这里插入图片描述

package com.itheima.demo03.Generic;

import java.util.ArrayList;
import java.util.Iterator;

public class Demo01Generic {
    public static void main(String[] args) {
        show02();

    }

    /*
        创建集合对象，使用泛型
        好处：
            1. 避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
            2. 把运行期异常(代码运行之后会抛出的异常)，提升到了编译期(写代码的时候会报错)
        弊端：
            泛型是什么类型，只能存储什么类型的数据
    */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        // list.add(1); // add(java.lang.String)in ArrayList cannot be applied to (int)

        // 使用迭代器遍历list集合
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s+"->"+s.length());
        }
    }

    /*
        创建集合对象，不使用泛型
        好处：
            集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
        弊端：
            不安全，会引发异常
    */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        // 使用迭代器遍历list集合
        // 获取迭代器
        Iterator it = list.iterator();
        // 使用迭代器中的hasNext和next遍历集合
        while(it.hasNext()) {
            // 取出元素也是Object类型
            Object obj = it.next();
            System.out.println(obj);

            // 想要使用String类特有的方法，length获取字符串的长度；不能使用 多态 Object obj = "abc";
            // 需要向下转型
            // 会抛出ClassCastException类型转换异常，不能把Integer类型转换为String类型
            String s = (String) obj;
            System.out.println(s.length());
        }
    }
}
/*
abc->3
*/

十九、定义和使用含有泛型的类

在这里插入图片描述

package com.itheima.demo03.Generic;
/*
    定义一个含有泛型的类，模拟ArrayList集合
    泛型是一个未知的数据类型，当我们不确定使用什么数据类型的时候，可以使用泛型
    泛型可以接收任意的数据类型，可以使用Integer, String, Student...
    创建对象的时候确定泛型的数据类型
*/
public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }

}

package com.itheima.demo03.Generic;

public class Demo02GenericClass {
    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);

        // 创建GenericClass对象，泛型使用String类型
        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("小明");
        String name1 = gc3.getName();
        System.out.println(name1);

    }
}
/*
1
小明
*/

二十、定义和使用含有泛型的方法

package com.itheima.demo03.Generic;
/*
    定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间

    格式：
        修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)) {
            方法体;
        }
    含有泛型的方法，在调用方法的时候确定泛型的数据类型
    传递什么类型的参数，泛型就是什么类型
*/
public class GenericMethod {
    // 定义一个含有泛型的方法
    public <M> void method01(M m) {
        System.out.println(m);
    }

    // 定义一个含有泛型的静态方法
    public static <S> void method02(S s) {
        System.out.println(s);
    }

}

package com.itheima.demo03.Generic;
/*
    测试含有泛型的方法
*/
public class Demo03GenericMethod {
    public static void main(String[] args) {
        // 创建GenericMethod对象
        GenericMethod gm = new GenericMethod();
        /*
            调用含有泛型的方法method01
            传递什么类型，泛型就是什么类型
        */
        gm.method01(10);
        gm.method01("abc");
        gm.method01(8.8);
        gm.method01(true);

        gm.method02("静态方法,不建议创建对象使用");

        // 静态方法，通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(1);
    }
}
/*
10
abc
8.8
true
静态方法,不建议创建对象使用
静态方法
1
*/

Only hand ripe

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【day012】Java学习，坚持就是胜利！

一、StringBuilder的构造方法和append方法package com.itheima.demo06.StringBuilder;/* java.lang.StringBuilder类：字符串缓冲区，可以提高字符串的效率构造方法： - public StringBuilder(): 构造一个空的StringBuilder容器。 - public StringBuilder(String str): 构造一个StringBuilder容器，
复制链接

扫一扫