学习java的第十天

于 2022-05-02 15:09:43 发布
阅读量171 收藏
点赞数
文章标签： java 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54059002/article/details/124541261
版权

包装类

概述

将基本数据类型包装起来形成一个类，这样就可以通过类中的方法来操作数据

装箱

基本数据类型—>包装类

//利用构造方法
Integer(int value);
Integer(String s);//传递的字符串必须为基本类型的字符串
//利用静态方法
static Integer valueOf(int i);
static Integer valueOf(String s);

public class Main {

    public static void main(String[] args) {
        //利用构造方法
        //构造一个对象，表示指定的值
        Integer integer1 = new Integer(11);
        Integer integer2 = new Integer("22");

        //利用静态方法
        Integer integer3 = new Integer(33);
        Integer integer4 = new Integer("44");
        //传递的字符串要是数字的

        System.out.println(integer1);
        System.out.println(integer2);
        System.out.println(integer3);
        System.out.println(integer4);
    }

拆箱

包装类—>基本数据类型

包装类无法直接参与运算，需拆箱

对象名.intValue();

int i = integer1.intValue();
System.out.println(i);

自动装箱与拆箱

基本类型的数据和包装之间相互转化

public class Demo1 {
    public static void main(String[] args) {
        //相当于 Integer in1 = new Integer(3);
        Integer in1 = 3;
        System.out.println(in1);
        //相当于 Integer in1 = new Integer(in1.intValue()+2);
        //又重新创造一个对象
        in1 = in1 + 2;
        System.out.println(in1);

    }
}

基本数据类型与String的转化

基本数据类型--->String;

基本数据类型直接与“”相连即可

String--->基本数据类型;
//无法转化为Character类
//利用包装类中parseXxx的静态方法

String str1 = "1234";
int num = Integer.parseInt(str1);
System.out.println(num);

集合

概述

  1. 集合是Java的一种容器，可以存储多个数据

  2. 与数组区别：

    • 数组长度固定，集合长度可变
    • 数组存储的是元素，集合存储的是对象

在这里插入图片描述

Collection常用功能

  • public boolean add(E e);

  • public void clear();

  • public boolean remave(E e);

  • public boolean contains(E e);

  • public boolean isEmpty()

  • public int size()

  • public Object[] toArray();//把集合元素存储到数组中

public class Main {
    public static void main(String[] args) {
        Collection<String> cll = new ArrayList<String>();

        cll.add("张三");
        cll.add("李四");
        cll.add("王五");
        cll.add("赵六");
        System.out.println(cll);

        cll.remove("张三");
        System.out.println(cll);//重写了toString方法

        boolean s = cll.contains("王五");
        System.out.println("是否有王五："+s);

        boolean empty = cll.isEmpty();
        System.out.println("是否为空："+empty);

        System.out.println("个数为："+cll.size());


        Object[] objects = cll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }

        cll.clear();//集合依然存在
        empty = cll.isEmpty();
        System.out.println("是否为空："+empty);

    }
}

Iterator迭代器（接口类）

迭代：当集合取出元素时，需判断是否有元素，如果有则取出，然后继续判断，直到将所有元素全部取出。这种取出方式的专业术语为迭代。

迭代器：对集合进行遍历

Collection接口中有一个方法（iterator）返回迭代器的实现类对象

//常用方法
boolean hasNext();
E next();//返回下一个元素

public class Demo1 {
    public static void main(String[] args) {
        Collection<String> cll = new ArrayList<String>();

        cll.add("张三");
        cll.add("李四");
        cll.add("王五");
        cll.add("赵六");

        Iterator<String> iterator = cll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //在所有元素取出时，在次使用next时，会报错
    }
}

分析：

在这里插入图片描述

增强for循环

所有单列集合都可以使用增强for，用来遍历集合和数组

//格式
for(集合/数组的数据类型 变量名 : 集合/数组名){
    sout(变量名);
}


public class Demo2 {
    public static void main(String[] args) {

        int nums[] = {12,33,67,533,90,56,35};
        for (int i : nums) {
            System.out.println(i);
        }

        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(2);
        list.add(66);
        list.add(46);
        list.add(89);
        list.add(23);

        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

泛型

概述

在这里插入图片描述

//使用泛型与不使用泛型

public class Demo3 {
    public static void main(String[] args) {
        //不使用泛型
        ArrayList list = new ArrayList();
        //默认为<Object>，于是用到了多态
        //因为利用了多态，则无法使用子类特有的方法

        list.add("lin");
        list.add(12);
        list.add(23.4);
        //容器内数据的类型不唯一

        for (Object o : list) {
            System.out.println(o);
        }
        //要想用子类方法，需要向下转型
        //容器内数据的类型不唯一,在向下转型时无法全部转化为统一类型
        //在编译阶段不报错，在运行时会出错，不安全

        //使用泛型，可以将异常提前到编译阶段
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("ll");
        //list1.add(12);  错误，数据类型不统
    }
}

泛型定义类

publivc calss 类名<E>{
    
}

public class Test <E>{
    public E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}
public class Dome4 {
    public static void main(String[] args) {
        Test<Integer> gc = new Test<Integer>();
        gc.setName(23);
        gc.setName(33);

        System.out.println( gc.getName());
        //只存储一个数据
        //getName()默认返回Object类型
    }
}

泛型定义方法

泛型定义在方法的修饰符和返回值类型之间

修饰符 <> 返回值 方法名（参数列表（使用泛型））{
    方法体
}
在调用方法时确定泛型类型

public class Test <E>{
    public <E> void math(E m){
        System.out.println(m);
    }
}
public class Dome5 {
    public static void main(String[] args) {
        Test list = new Test();

        list.math(22);

        Dome5.math(33);
        //使用泛型的静态函数尽量不创建对象
    }
    public static <E> void math(E m){
        System.out.println(m);
    }
}

泛型定义接口

public interface 接口名<E>{
    抽象函数（参数列表用泛型）;
}

public interface Test2 <E>{
    public abstract void print(E m);
}
public class Dome6 implements Test2<String>{
    @Override
    public void print(String m) {
        System.out.println(m);
    }
}
public class Dome7<I> implements Test2<I> {
    @Override
    public void print(I m) {
        System.out.println(m);
    }
}
public class Main {
    public static void main(String[] args) {
    	//第一种使用
        //在实现类确定数据类型
        Dome6 test = new Dome6();
        test.print("lin");
        //在船舰对象时确定数据类型
        Dome7<String> test2 = new Dome7<>();
        test2.print("王");
    }
}

泛型通配符

当我们不知道使用什么数据类型来接收时，此时可用？

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

public class Dome8 {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(12);
        integers.add(13);
        integers.add(14);

        ArrayList<String> strings = new ArrayList<>();
        strings.add("lin");
        strings.add("wang");
        strings.add("zhao");
        
        //使用通配符，使一个函数可以打印多个数据类型
        printArray(integers);
        printArray(strings);
        
        //ArrayList<?> list2 = new ArrayList<?>(); 无法在定义时使用，在作为参数时才可
    }
    //如果数据类型确定了，那么这个函数只能被特顶的数据类型所使用
    
    public static void printArray(ArrayList<?> list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}
//泛型无继承，ArrayList<Object>,也无法满足多个数据类型

受限泛型

  • 上限：使用的泛型只能是E类型的子类或本身
? extends E
  • 下限：使用的泛型只能是E类型的父类或本身
? super S

public static void get(ArrayList<? extends Number> coll);
//在调用该方法时，传递的参数只能是，Number的子类或本身
/*
String str = "lin";
get(str);//错误，String与Number不存在继承关系

*/

t){
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
//泛型无继承，ArrayList,也无法满足多个数据类型




## 受限泛型

* 上限：使用的泛型只能是E类型的子类或本身

```java
? extends E
  • 下限：使用的泛型只能是E类型的父类或本身
? super S

public static void get(ArrayList<? extends Number> coll);
//在调用该方法时，传递的参数只能是，Number的子类或本身
/*
String str = "lin";
get(str);//错误，String与Number不存在继承关系

*/
枫雨雾灯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值