Java学习笔记（五）

最新推荐文章于 2024-05-13 21:50:21 发布

掉发阿龙

最新推荐文章于 2024-05-13 21:50:21 发布

阅读量160

点赞数 1

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_45184360/article/details/115497325

版权

Java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Java学习笔记（五）

StringBuilder类

概念：java.lang.StringBulider类：字符串缓冲区，提高字符串的效率

String类：字符串是一个常量，他的值在创建之后不能更改，字符串底层是一个被final修饰的byte数组(private final byte[] value)，进行字符串的相加，内存中就会有多个字符串，占用空间多，效率低下
StringBuilder类：字符串缓冲区，可以提高字符串的操作效率（看成一个长度可变的字符串）底层也是一个byte数组(byte[] value = new byte[16])，但是没有被final修改，可以改变长度
StringBuilder在内存中始终是一个数组，占用的空间少，效率高，如果超出了StringBuilder的容量，会自动扩容

构造方法

public StringBuilder()  //构造一个不带任何字符串的字符串生成器，其初始容量为16个字符
public StringBuilder(String str)  //构造一个字符串生成器，并初始化为指定的字符串内容

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

常用方法

public StringBuilder append(....)//添加任意类型数据的字符串形式，并返回当前对象自身
public Sting toString()//将当前StringBuilder对象转换成String对象

//创建StringBuilder对象
StringBuilder sb = new StringBuilder();
//使用append方法往StringBuilder中添加数据
//append方法返回的是this调用方法的对象sb.this==sb
//StringBuilder sb1 = sb.append("abc");//把sb地址赋值给sb1
//System.out.println(sb);//abc
//System.out.println(sb1);//abc
//System.out.println(sb==sb1);//true
//sb.append("abc");
//sb.append(1);
//sb.append(true);
//sb.append(8.8);
//sb.append('中');
//链式编程：返回值是一个对象，可以继续调用方法
sb.append("abc").append(1).append(true).append(8.8).append('中');
System.out.println(sb);//abc1true8.8中
/*
StringBuilder和String可以相互转换：
String->StringBuilder:可以使用StringBuilder的构造方法：public StringBuilder(String str)
StringBuilder->String:可以使用StringBuilder中的toString方法
*/
String str = sb.toString();
System.out.println(s);//abc1true8.8中

包装类

概念：

基本数据，使用起来非常方便，但是没有对应的方法来操作这些基本类型的数据，可以使用一个类，把基本类型的数据装起来，在类中定义一些方法，这个类叫做包装类，我们可以使用类中的方法来操作这些基本数据类型的数据

装箱和拆箱

基本数据类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“

装箱：从基本数据类转换成对应的包装类对象
拆箱：从包装类对象转换成对应的基本数据类型

基本数据类---->包装类对象(装箱)

//构造方法
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对象

Integer i = new Interger(4);//使用构造函数
Integer i1 = Integer.valueOf(4);//使用包装类中的valueOf方法

包装类对象---->基本数据类型(拆箱)

//成员方法
int intValue()//以int类型返回该Integer的值

int num = i.intValue();

自动装箱和自动拆箱

从Java 5开始，基本数据类型与包装类的装箱、拆箱动作可以自动完成

//相当于Integer i = new Integer();
Integer i = 4;//自动装箱，相当于Integer i  = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转换成基本数据类型（走动拆箱）i.intValue()+5;
//加法运算完成后，再次装箱，把基本数据类型数值转换成包装类

//ArrayList集合无法直接存储整数，可以储存Integer包装类
ArrayList<Integer> list = new ArrayList<>();
list.add(1);//--->自动装箱 list.add(new Integer(1));
int a = list.get(0);//--->自动装箱 list.get(0).intValue();

基本数据类型与字符串之间的转换

基本数据类----->字符串

基本数据类型的值+"" （最简单的方法）
包装类的静态方法toString(参数) （不是Object类的toString()重载）
```
static String toString(int i)//返回一个指定整数的String对象
```

String类的静态方法valueOf(参数)

static String valueOf(int i)//返回int参数的字符串

字符串----->基本数据类型

使用包装类的静态方法parseXXX("数值类型的字符串");

Integer类：

static int parseInt(String s)

Double类：

static double parseDouble(String s)

//基本数据类型---->字符串
int i1 = 100;
String s1 = i1 + "";
System.out.println(s1+100);//100200
String s2 = Integer.toString(100);
System.out.println(s2+100);//100200
String s3 = String.valueOf(100);
System.out.println(s3+100);//100200
//字符串---->基本数据类型
int i = Integer.parseInt(s1);
System.out.println(i+100);//200
int a = Integer.parseInt('a');//NumberFormatException 错误
System.out.println(a);

Collection集合

概述：

集合：集合是Java提供的一种容器，可以用来存储多个数据

集合和数组既然都是容器，有什么区别呢？

数组的长度是固定的，集合的长度是可变的
数组中存储的是同以类型的元素，可以存储基本数据类型值，集合存储的都是对象，而且对象的类型可以不一致，在开发种一般当对象多的时候，使用集合存储

集合框架

集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map

Collection：单列集合列的根接口，用于存储一系列符合某种规则的元素，它的两个重要的子接口，分别是java.util.List和java.util.Set，其中List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，Set接口的主要实现类有java.util.HashSet和java.util.TreeSet
在这里插入图片描述

Collection集合常用功能

Collection是所有单列集合的父接口，因此在Collection中定义的单列集合（List/Set）通用的游戏额方法，这些方法可以用于操作所有的单列集合

public boolean add(E e)//把给定的对象添加到当前集合中
public void clear()//清空集合中所有的元素
public boolean remove(E e)//在集合中删除指定的元素
public boolean contains(E e)//判断当前集合中是否包含给定的对象
public boolean isEmpty()//判断当前结合是否为空
public int size()//返回集合中元素的个数
public Object[] toArray()//把集合中的元素，存储到数组中

 //使用多态创建集合对象
Collection<String> coll  = new ArrayList<>();
System.out.println(coll);//[] 重写了toString方法
boolean b = coll.add("张三");
System.out.println(b);//true
System.out.println(coll);//[张三]
coll.add("李四");
coll.add("王五");
coll.add("赵六");
System.out.println(coll);//[张三, 李四, 王五, 赵六]
boolean b1 = coll.remove("王五");
System.out.println(b1);//true
System.out.println(coll);//[张三, 李四, 赵六]
boolean b2 = coll.contains("张三");
System.out.println(b2);//true
System.out.println(coll.isEmpty());//false
System.out.println(coll.size());//3
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}
coll.clear();//不删除集合，集合还存在，只是集合中没有元素
System.out.println(coll);//[]

Iterator接口

在程序开发中，经常需要遍历集合中的所有元素，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但是它与Collection、Map接口有所不同。Collection和Map接口主要用于存储元素，而Iterator主要是用于迭代访问(遍历)Collection中的元素，Iterator也被称为迭代器

想要遍历Collection集合，那么手现需要获取该集合的迭代器

public Iterator iterator()//获取集合对应的迭代器

迭代：即Collection集合元素的通用获取方法，在获取元素之前先要判断集合元素中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就再取出来，一直把集合中的所有元素全部取出来，这种方式称为迭代。

Iterator接口中的常用方法：

public E next()//返回迭代的下一个元素（取出集合中的下一个元素）
public boolean hasNext()//如果仍有元素可以迭代，则返回true

迭代器的使用步骤：

使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接受(多态)
使用Iterator接口中的方法hasNext判断还有没有下一个元素
使用Iterator接口中的方法next取出集合中的下一个元素

public class Demo01 {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");
        /*
        * 使用集合中的方法`iterator()`获取迭代器的实现类对象，使用`Iterator`接口接受(多态)
        * 注意：Iterator<E>接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
        * */
        //多态  接口                  实现类对象
        Iterator<String> iterator = coll.iterator();
        //使用while循环
        /*
        * 使用`Iterator`接口中的方法`hasNext`判断还有没有下一个元素
        * */
        while (iterator.hasNext()){
            /*
            * 使用`Iterator`接口中的方法`next`取出集合中的下一个元素
            * */
            System.out.println(iterator.next());
        }
        System.out.println("-----------------------------------------------");
        //使用for循环
        for (Iterator<String> iterator2 = coll.iterator();iterator2.hasNext();){
            System.out.println(iterator2.next());
        }
    }
}

迭代器的实现原理

在这里插入图片描述

增强for循环

增强for循环(也称for each循环)是JDK 1.5以后出来的一个高级for循环，专门用来遍历数组和集合的，它的内部原理是一个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作

格式：

for(集合/数组的数据类型 变量名 : 集合名/数组名){
    //操作代码
}

它用于遍历Collection和数组，通常只进行遍历元素，不要再遍历的过程中对集合元素进行增删操作

public class Demo01 {
    public static void main(String[] args) {
        //增强for循环遍历数组
        int[] arr = {1,3,7,9,5};
        for (int i : arr){
            System.out.println(i);
        }
        System.out.println("================");
        //增强for循环遍历集合
        Collection<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        for (String s : list){
            System.out.println(s);
        }
    }
}

/*结果：
1
3
7
9
5
================
aaa
bbb
ccc
ddd
*/

泛型

在这里插入图片描述

使用泛型的好处

public class Demo{
    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);//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);//abc-->3
        }
    }
    /*
    创建集合对象，不适用泛型
    好处：
    	集合不使用泛型，默认的类型就是Object类型，可以春初任意类型的数据
    弊端:
    	不安全，会引发异常
    */
    private static void show01(){
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);
        //使用迭代器遍历list集合
        Iterator it = list.iterator();
         while(it.hasNext()){
            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());
        }
    }
}

泛型的定义与使用

在集合中会大量使用泛型
泛型，用来灵活的将数据类型应用到不同的类、方法、接口当中，将数据类型作为参数进行传递

定义何使用含义泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {
	//...
}

/*
定义一个含有泛型的类，模拟ArrayList集合
泛型是一个位置的数据类型，当我们不确定使用什么数据类型的时候，可以使用泛型
泛型可以接受任意的数据类型，可以使用Integer,String,Student....
创建对象的时候确定泛型的数据类型
*/
public class GenericClass<E> {
    private E name;
    public E getName(){
        retrun name;
    }
    public void setName(E name){
        this.name = name;
    }
}
public class Demo{
    public static void main(String[] args){
        //不写泛型默认为Object类型
        GenericClass gc = new GenericClass();
        gc.setName("只能字符串");
        Object obj = gc.getName();
        //创建GenericClass对象，泛型使用Integer类型
        GenericClass<Integer> gc1 = new GenericClass<>();
        gc1.setName(1);
        Integer name = gc1.getName();
        System.out.println(name);//1
    }
}

含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){
	//方法体
}

/*
定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间
含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型
*/
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 Demo{
    public static void main(String[] args){
        GenericMethod gm = new GenericMethod();
        /*
        调用含有泛型的方法
        传递什么类型，泛型就是什么类型
        */
        gm.method01(10);
        gm.method01("abc");
        gm.method01(8.8);
        gm.method01(true);
        //静态方法，通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(1);
    }
}

含有泛型的接口

定义格式：

修饰符 interface 接口名<代表泛型的变量>{
    //...
}

/*
定义含有泛型的接口
*/
public interface GenericInterface<I> {
    public abstract void method();
}

/*
含有泛型的接口,第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
public interface Iterator<E>{
	E next();
}
Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法默认泛型为String
public final class Scanner implements Iterator<String>{
	public String next(){}
}
*/
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void method(String s){
        System.out.println(s);
    }
}

/*
含有泛型的接口的第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
public interface List<E>{
	boolean add(E e);
	E get(int index);
}
public class ArrayList<E> implements List<E>{
	public boolean add(E e){}
	public E get(int index){}
}
*/
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
    @Override
    public void method(I i){
        System.out.println(i);
    }
}

public class Demo{
    public static void main(String[] args){
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method("字符串");
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method(10);
    }
}

泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身无法使用

泛型的通配符：不知道使用什么类型来接收的时候，此时可以使用？，？表示位置通配符

此时只能接受数据，不能往该集合中存储数据

public static void main(Stirng[] args){
    Collection<Integer> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
//?表示可以接收任意类型
public static void getElement(Collection<?> coll){}

/*
泛型的通配符：
	?:代表任意数据类型
使用方式：
	不能创建对象使用
	只能作为方法的参数使用
*/
public static void main(Stirng[] args){
    ArrayList<Integer> list1 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    ArrayList<String> list2 = new ArrayList<>();
    list2.add("a");
    list2.add("b");
}
/*
定义一个方法，能遍历所有类型的ArrayList集合
这时候我们不知道ArrayList集合使用什么的数据类型，可以使用泛型的通配符?来接收数据类型
注意：
	泛型没有继承的概念
*/
public static void printArray(ArrayList<?> list){
    Iterator<?> it = list.iterator();
    while(it.hasNext()){
        //it.next()方法，取出的元素是Object类型，可以接收任意的数据类型
        Object o = it.next();
        System.out.println(o);
    }
}

通配符高级使用-受限泛型

/*
泛型的上限限定： ? extends E  代表使用的泛型只能是E类型的子类或者本身
泛型的下限限定： ? super E    代表是哟个的泛型只能是E类型的父类或者本身
*/
public static void main(String[] args){
	Collection<Integer> list1 = new ArrayList<>();
    Collection<String> list2 = new ArrayList<>();
    Collection<Number> list3 = new ArrayList<>();
    Collection<Object> list4 = new ArrayList<>();
    
    getElement1(list1);
    getElement1(list2);//报错
    getElement1(list3);
    getElement1(list4);//报错
    
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
}
/*
类与类之间的继承关系
Integer extends Number extends Object
String extends Object
*/

//泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
//泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement1(Collection<? super Number> coll){}

掉发阿龙

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java学习笔记（五）

Java学习笔记（五）StringBuilder类概念：java.lang.StringBulider类：字符串缓冲区，提高字符串的效率String类：字符串是一个常量，他的值在创建之后不能更改，字符串地城是一个被final修饰的byte数组(private final byte[] value)，进行字符串的相加，内存中就会有多个字符串，占用空间多，效率低下StringBuilder类：字符串缓冲区，可以提高字符串的操作效率（看成一个长度可变的字符串）底层也是一个byte数组(byte[] va
复制链接

扫一扫