java笔记（213-256）

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量150 收藏
点赞数
分类专栏： java 文章标签： java eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51930376/article/details/120781215
版权

这里写目录标题

异常：

  • try catch方法处理异常：

在这里插入图片描述
异常类名从控制台上寻找：
在这里插入图片描述
由帮助文档可得，此异常为运行时异常
在这里插入图片描述
而这类异常则是编译型异常：
在这里插入图片描述

  • 两种异常

在这里插入图片描述
1.运行时异常也可以用try catch处理，也可以不用
2.编译异常指可能会出问题，但不一定要出问题，所以电脑会提醒改动，否则无法正常编译i。

package 实验;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

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

        System.out.println("开始");
        method1();
        System.out.println("结束");
        method2();

    }
    //编译时异常
    public static void method2(){
        try{
            String s="2048-08-09";
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
            Date d=sdf.parse(s);
            System.out.println(d);
        }catch(ParseException e){
            e.printStackTrace();
        }
    }

    //运行时异常
    public static void method1() {
        try {
            int[] arr = {1, 2, 3};
            System.out.print(arr[3]);
        } catch (ArrayIndexOutOfBoundsException e) {//相当于new一个异常类的对象
            System.out.println("不存在此元素");
            e.printStackTrace();//在控制台输出异常原因
            System.out.println(e.getMessage());//返回throwable的详细消息字符串
            System.out.println(e.toString());//更加详细的描述
        }
    }
}
  • throws处理异常：
    在这里插入图片描述
    在运行时异常时无太大意义
    public static void main(String[] args) {

        System.out.println("开始");
        method1();
        System.out.println("结束");
        System.out.println("开始");
        try{
            method2();
        }catch(ParseException e){
            e.printStackTrace();
        }
        System.out.println("结束");

    }
    //编译时异常
    public static void method2() throws ParseException {

            String s="2048-08-09";
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
            Date d=sdf.parse(s);
            System.out.println(d);

    }

在编译型异常中，throw可以认为 是将异常抛出，即暂时不进行处理（但是还是没有处理异常，在主函数中还是需要用try catch进行处理，即谁来调用谁处理）

  • 自定义异常
    在这里插入图片描述

Exception即为异常类的父类
在这里插入图片描述
依次选中nnn和super按ctrl+b跟进，可得最后将message传给了detailMessage
在这里插入图片描述
创建自己的异常类对象

package 实验;

public class nnn extends Exception {
    public nnn(){

    }
    public nnn(String message){
        super(message);
    }
}

先要throw一个对象（nnn），然后再throws出去

package 实验;

public class java {

       public void check(int score) throws nnn{
           if(score<0||score>100){
               throw new nnn(“你给的分钟数有误”);
           }else{
               System.out.println("分数正常");
           }
       }
   }

由于check所在的类中，抛出nnn异常对象，而这个异常继承于Extend，所以是一个编译时异常，所以check就需要用try catch来处理。

package 实验;

import java.util.Scanner;

public class text {
    public static void main(String[] args)  {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入成绩：");
        int i= sc.nextInt();
        java a=new java();
        try {
            a.check(i);
        } catch (nnn e) {
            e.printStackTrace();
        }
    }
}

二者区别：
在这里插入图片描述
一旦走了throw这一步就一定会有异常，因为new了一个异常对象，但是如果没有这一步的话就不一定有异常。

集合体系结构：

在这里插入图片描述
Collection是集合的顶层接口，不能被实例化

  • Collection常用方法

在这里插入图片描述

  • Collection集合的遍历：

在这里插入图片描述

package 实验;

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

public class collection {
    public static void main(String[] args) {
        Collection<String> e=new ArrayList<String>();
        e.add("hello");
        e.add("world");
        e.add("java");
        Iterator<String> it =e.iterator();//得到迭代器对象it
        sout（"it.next"）;//迭代器方法
        sout（"it.next"）;
        sout（"it.next"）;
        
    }
}

e.iterator方法的原码如下，相当于多态
在这里插入图片描述
hasNext方法：判断有无后继元素

package 实验;

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

public class collection {
    public static void main(String[] args) {
        Collection<String> e=new ArrayList<String>();
        e.add("hello");
        e.add("world");
        e.add("java");
        Iterator<String> it =e.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

- list集合：
在这里插入图片描述

  • list特有的方法：
    （Arraylist有但是Collection中没有）
    在这里插入图片描述
    ( size() 用来求集合大小； length用来求数组大小； length()用来求字符串大小)
    在这里插入图片描述
  • 并发修改异常：
    在这里插入图片描述
    报错
    在这里插入图片描述
    成功输出：
    在这里插入图片描述
    在这里插入图片描述
    简而言之：迭代器是依赖于集合而存在的，在判断成功后，集合的中新添加了元素，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
    更准确的解释
  • 列表迭代器

列表迭代器和特有方法：
在这里插入图片描述
正向遍历：
在这里插入图片描述
逆向遍历：
·
add方法：
在这里插入图片描述
注意：这里是通过列表迭代器来添加的，而上面的并发修改异常时通过list集合来添加的。
（输出的是hello world javaee java，是在world后添加，而不是在集合的最后添加）

  • 增强for循环：

在这里插入图片描述
在这里插入图片描述
执行下列代码后，控制台抛出了并发修改异常，说明增强for的内部就是一个Iterator修改器
在这里插入图片描述

  • 遍历集合的三种方式：

在这里插入图片描述

只是为了遍历的话，就用增强for，最方便
若需要索引的话就是用增强for

Arraylist和LinkList的特点：
在这里插入图片描述

  • LinkList特有的功能：

在这里插入图片描述

  • set集合的概述和特点

1.不包含重复元素
2.没有带索引的方法，所以不能用普通for循环

package 实验;

import java.util.*;

public class collection {
    public static void main(String[] args) {
        Set<String> sc=new HashSet<String>();
        sc.add("hello");
        sc.add("world");
        sc.add("java");
        sc.add("java");
        for(String s:sc){
            System.out.println(s);
        }
    }
}

输出：
在这里插入图片描述

  • 哈希值：
student s1=new student(参数，参数);
sout("s1.hashCode()");
sout("重地");1179395
sout("种地")1179395
1.同一对象的哈希值是相同的
2.默认情况下，哈希值不同，但是通过方法的重写，可以实现不同对象哈希值相同（String重写了hashCode方法）
  • HashSet集合的概述和特点：
    在这里插入图片描述
  • HashSet保证元素唯一性的分析
    在这里插入图片描述
    要保证元素的唯一性，就需要重写hashCode（）和equal（）
    （比如在student类中，就需要重写，alt+insert选中equal和hashcode后即可自动重写）？？？
    （好像只是LinkedHashset才需要重写）
  • LinkedHashSet集合特点
    在这里插入图片描述
  • treese集合的特点：
    在这里插入图片描述
package 实验;

import java.util.*;

public class collection {
    public static void main(String[] args) {
        TreeSet<Integer> ts =new TreeSet<Integer>();//<>中是包装类
        ts.add(10);
        ts.add(20);
        ts.add(30);
        ts.add(40);
        ts.add(50);
        ts.add(30);
        for(Integer i : ts){
            System.out.println(i);
        }
        Iterator<Integer> j=ts.iterator();
        while(j.hasNext()){
            System.out.println(j.next());
        }

    }
}
  • 自然排序Comparable的使用：
package 实验;

import java.util.*;

public class collection {
    public static void main(String[] args) {
        TreeSet<student> ts =new TreeSet<student>();
        student s1=new student ("张蔚原",19);
        student s2=new student("蒋佳颖",20);
        student s3=new student("许杰",19);
        student s4=new student("余鑫",19);
        student s5=new student("张蔚原",19);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        for(student i : ts){

            System.out.println(i.getName()+","+i.getAge());
        }
        Iterator<student> j=ts.iterator();
        while(j.hasNext()){
            student k=j.next();
            System.out.println(k.getName()+","+k.getAge());
        }
    }
}

此时会报错，学生类不能转化成自然排序接口，所以需要在student中实现comparable接口并重写

package 实验二;

import java.util.Objects;

public class student2 implements Comparable<student2> {
    private  String name;
    private  int age;

    @Override
    public int compareTo(student2 s) {
        return 0;
    }

    public student2() {
    }

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

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        student2 student2 = (student2) o;
        return age == student2.age && Objects.equals(name, student2.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public student2(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

然后再测试函数中：

package 实验二;

import 实验.student;

import java.util.*;

public class text2 {
    public static void main(String[] args) {
        TreeSet<student2> ts =new TreeSet<student2>();
        student2 s1=new student2 ("张蔚原",19);
        student2  s2=new student2("蒋佳颖",20);
        student2 s3=new student2("许杰",19);
        student2 s4=new student2("余鑫",19);
        student2 s5=new student2("张蔚原",19);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        for(student2 i : ts){

            System.out.println(i.getName()+","+i.getAge());
        }
        System.out.println("---------");
        Iterator<student2> j=ts.iterator();
        while(j.hasNext()){
            student2 k=j.next();
            System.out.println(k.getName()+","+k.getAge());
        }
    }
}

但是此时的输出是：
在这里插入图片描述
原因是comparable中返回的值是0，说明元素是重复的，就不会再添加
如果返回值是一的话就会输出

张蔚原,19
蒋佳颖,20
许杰,19
余鑫,19
张蔚原,19
---------
张蔚原,19
蒋佳颖,20
许杰,19
余鑫,19
张蔚原,19

即使顺序输出

return -1的话就会逆置输出

 @Override
    public int compareTo(student2 k) {
        int flag=this.age-k.age;//按年龄升序排列
        int flag2=k.age-this.age;//按年龄降序
        return flag;
    }

当年龄相同时：

@Override
    public int compareTo(student2 k) {
        int flag=this.age-k.age;
        int flag2=flag==0?this.name.compareTo(k.name):flag;//还能够防止重复
        return flag2;
    }

在这里插入图片描述
comparable比较器排序

package 实验二;

import 实验.student;

import java.util.*;

public class text2 {
    public static void main(String[] args) {
        TreeSet<student2> ts =new TreeSet<student2>(new Comparator<student2>() {
            @Override
            public int compare(student2 o1, student2 o2) {

                int flag=o1.getAge()-o2.getAge();
                int flag2=flag==0?o1.getName().compareTo(o2.getName()):flag;
                return flag2;
            }
        });
        student2 s1=new student2 ("张蔚原",19);
        student2  s2=new student2("蒋佳颖",20);
        student2 s3=new student2("许杰",19);
        student2 s4=new student2("余鑫",19);
        student2 s5=new student2("张蔚原",19);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        for(student2 i : ts){

            System.out.println(i.getName()+","+i.getAge());
        }
        System.out.println("---------");
        Iterator<student2> j=ts.iterator();
        while(j.hasNext()){
            student2 k=j.next();
            System.out.println(k.getName()+","+k.getAge());
        }
    }
}

若 TreeSet ts =new TreeSet（）为无参构造方法的话，即调用student中的：

@Override
    public int compareTo(student2 k) {
        int flag=this.age-k.age;
        int flag2=flag==0?this.name.compareTo(k.name):flag;
        return flag2;
    }


余鑫,19
张蔚原,19
许杰,19
蒋佳颖,20
---------
余鑫,19
张蔚原,19
许杰,19
蒋佳颖,20

若TreeSet ts =new TreeSet(new Comparator()为带参构造方法：
（通过比较器进行排序就需要接受其接口的实现类对象，所以可以运用匿名内部类形式）

 TreeSet<student2> ts =new TreeSet<student2>(new Comparator<student2>() {
            @Override
            public int compare(student2 o1, student2 o2) {

                int flag=o1.getAge()-o2.getAge();
                int flag2=flag==0?o1.getName().compareTo(o2.getName()):flag;
                return flag2;
            }
        });

余鑫,19
张蔚原,19
许杰,19
蒋佳颖,20
---------
余鑫,19
张蔚原,19
许杰,19
蒋佳颖,20

在这里插入图片描述

  • 案例：按照总成绩降序（主），语文成绩降序排序
    在这里插入图片描述

泛型：

在这里插入图片描述

  • 泛型类：
    在这里插入图片描述
    只需要一个类就能解决不同泛型而导致的不兼容问题：（T可以是任意类型）
package 泛型;

public class shiyan1<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

在这里插入图片描述
输出：
在这里插入图片描述
而如果不使用泛型类的话，实现上述需求就需要三各类中定义的get set方法来实现

  • 泛型方法：
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    泛型接口：

可变参数：

package 泛型;

public class 可变参数 {
    public static int sum(int ...a){
        int sum=0;
        for(int i:a){
            sum+=i;
        }
        return sum;
    }
}


package 泛型;

public class 可变参数text {
    public static void main(String[] args) {
        System.out.println(可变参数.sum(10,20,30,40));
        System.out.println(可变参数.sum(20,30,40));
        System.out.println(可变参数.sum(30,40));
    }
}
mallocbict
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java学习笔记-Scokect.pdf
11-29
Java学习笔记-Scoket.pdf Java学习笔记-Scoket.pdf是关于Java编程语言中Socket编程的学习笔记，涵盖了Socket编程的基础知识、Java中Socket的使用、Socket通信的原理及应用等方面的内容。 Socket编程的基础知识 在...
重写报错The type ** must implement the inherited abstract method Comparable.compareTo(Object)
weixin_45241364的博客
01-18 2534
The type ** must implement the inherited abstract method Comparable.compareTo(Object)
R中数据的标准化0-1标准化
热门推荐
Erin的博客
07-12 3万+
8. 数据标准化 数据标准化，是将数据按比例缩放，使之落入到特定区间，一般我们使用0-1标准化； x=(x-min)/(max-min) >data <- read.csv('1.csv', fileEncoding='utf-8') > data class name score 1 一班 朱志斌 120 2 一班 朱凤 122 3 一班 郑丽萍 14
python数据分析入门【二】 --- 数据处理
qq_33934427的博客
08-26 1万+
python数据分析入门【二】 — 数据处理 上一章内容python数据分析入门【一】 — DataFrame & Series 下一章内容python数据分析入门【三】 — 数据分析 文章目录python数据分析入门【二】 --- 数据处理1、数据导入和导出1.1 数据的导入1）一般方式导入文件2）导入csv文件3）导入文本文件4）导入excel文件（后缀xlsx）1.2 数据的导出1）导出csv/txt文件2）导出xlsx文件2、值处理A、重复值处理2.1 用duplicated()找出重复位置
电路
许杰(嵌入式)
10-19 278
 电路（网络）分析的一般方法：图解比较   支路法 回路法 节点法 变量 b条支路电流 b-(n-1)个回路电流 (
第一次网络赛之许杰浩题解
weixin_33806509的博客
09-07 81
Pretty PoemTime Limit:2 Seconds Memory Limit:65536 KB Poetry is a form of literature that uses aesthetic and rhythmic qualities of language. There are many famous poets in the contemporary era...
java笔记 Java-Web笔记 J2EE三大框架笔记
10-19
首先，Java笔记主要涉及Java语言的基础语法、面向对象编程概念、异常处理、集合框架、多线程、IO流、网络编程等内容。Java的基础是理解其核心特性，如类、接口、继承、封装、多态等面向对象概念。异常处理确保程序在...
Java笔记---李兴华
04-15
Java笔记---李兴华---Java笔记---李兴华-----Java笔记---李兴华--Java笔记---李兴华
Java自学--基础笔记
07-19
学习Java过程记录笔记
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。Java以其“一次编写，到处运行”的特性，成为跨平台应用开发的首选语言。Java的基础部分主要包括...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 407
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 788
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 774
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 141
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 326
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1889
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 974
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
javafx java-stream-player 调用笔记本摄像头
04-29
而Java Stream是一个在Java 8中新增的功能，它使得Java处理数据流变得更为方便和高效，从而可以应用于多种场景，包括音视频流采集。 如果要使用JavaFX和Java Stream来调用笔记本摄像头，首先需要了解JavaFX中Media...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值