java第四周学习笔记

2022-05-03 01:48:50

文章目录

2022.1.25
- Map
2022.1.26
2022.1.27
- 泛型
- 其他
2022.1.28
- 泛型
- 线程
- - Thread
- 其他
2022.1.29
- 线程
2022.1.30
- on java 8读书笔记(摘录)
- 线程

2022.1.25

Map

有关于如何处理重复数据输入以及错误信息输入

while(i<3){
            String id = input.next();
            if(GoodMap.containsKey(id)){
                continue;
            }
            String name = input.next();
            double value =0;
            try{
                value=input.nextDouble();
            }catch(InputMismatchException e){
                input.next();
                continue;
            }
            Goods good = new Goods(id,name,value);
            GoodMap.put(id,good);
            i++;
        }

注意下,输入信息错误的那里要加input.next(),因为错误输入的信息仍然保存在缓冲区内部,会被下一个循环错误读取,所以在框架里要写.

2022.1.26

排序

Comparator接口

有关于Comparator接口,这个接口一般是作为参数放在排序方法里的,最开始我也觉得挺别扭的,后面想了想,这也主要是因为在java中,单独的一个函数不能存在,所以设计了这样的一个接口,让我们能通过类来间接调用函数

public class test {
    public static void main(String[] args) {
        Cat a= new Cat("b",311,"fjkdjfdkd");
        Cat b= new Cat("a",322,"fjkdfjdk");
        Cat c= new Cat("c",313,"fjakdfj");
        ArrayList<Cat> d = new ArrayList<Cat>();
        d.add(a);
        d.add(b);
        d.add(c);
        System.out.println("前");
        for(Cat e : d){
            System.out.println(e.toString());
        }
        System.out.println("后");
        Collections.sort(d,new zimu());
        for(Cat e : d){
            System.out.println(e.toString());
        }
    }
}

public class zimu implements Comparator<Cat> {
    @Override
    public int compare(Cat a,Cat b){
        return a.getName().compareTo(b.getName());
    }

}

注意下,我们用类实现接口的过程中实现的是compare方法而不是compareTo方法
然后排序的过程中,注意要new一个对象实例出来,不然内部的方法是无法被访问的

Comparable接口

如何使用,在自己要实现的类中实现Comparable接口就好

public class Goods implements Comparable<Goods>{
    private String id;
    private String name;
    private double price;

    public Goods(String id, String name, double price){
        this.id=id;
        this.name=name;
        this.price=price;
    }

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

    public String getName() {
        return name;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return  "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price ;
    }

    @Override
    public int compareTo(Goods o) {
        return this.price>o.price ? 1 : -1;
    }

}

public class two {
    public static void main(String[] args){
        Goods one =  new Goods("3124","iphone",31232131);
        Goods two = new Goods("313","tel",314);
        Goods three = new Goods("411","fks",43143);
        ArrayList<Goods> list = new ArrayList<Goods>();
        list.add(one);
        list.add(two);
        list.add(three);
        System.out.println("first");
        for(Goods good : list){
            System.out.println(good);
        }
        System.out.println("after");
        Collections.sort(list);
        for(Goods good : list){
            System.out.println(good);
        }
    }
}

其实自我感觉这两个不是特别的难,一个其实就是将判定方法写在了外面,另一个就是将判定方法写在了类的内部,没啥难理解的,只是要注意下Comparable接口后<>里自己的类

其他

int n= new Double(89.7-34).intValue();
System.out.println(n);

double n =  Double.parseDouble("3213");
        System.out.println(n);

int n =  Integer.parseInt("432432");
        System.out.println(n);

int n =  Integer.valueOf("4343");
        System.out.println(n);

下面是源码

//先调用parseInt获得int值，然后封装成Integer对象，注意封装的逻辑，有缓存
 public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
 }
    
 public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
 if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
 }
 //直接转换，获得int值
 public static int parseInt(String s) throws NumberFormatException {
    return parseInt(s,10);
 }

可以看出,parseInt直接输出的原始数据而valueOf又对它进行了一次封装;

Description

This method is used to get the primitive data type of a certain String. parseXxx() is a static method and can have one argument or two.

Syntax

Following are all the variants of this method −
static int parseInt(String s)
static int parseInt(String s, int radix)
Parameters

Here is the detail of parameters −

s − This is a string representation of decimal.

radix − This would be used to convert String s into integer.

Return Value

parseInt(String s) − This returns an integer (decimal only).

parseInt(int i) − This returns an integer, given a string representation of decimal, binary, octal, or hexadecimal (radix equals 10, 2, 8, or 16 respectively) numbers as input.

这里radix就是表示前面的字符串是什么进制下的数字,然后统一转化成十进制

2022.1.27

泛型

如何在方法中调用带有泛型的子类容器

public class one {
    public void test(List<? extends father> a){
        for(father e : a){
            e.function();
        }
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        List<sonOne> lis1 = new ArrayList<sonOne>();
        sonOne one1= new sonOne();
        sonOne one2 = new sonOne();
        lis1.add(one1);lis1.add(one2);
        List<sonTwo> lis2 = new ArrayList<sonTwo>();
        sonTwo two1= new sonTwo();
        sonTwo two2= new sonTwo();
        lis2.add(two1);lis2.add(two2);
        List<sonThree> lis3 = new ArrayList<sonThree>();
        sonThree three1= new sonThree();
        sonThree three2= new sonThree();
        lis3.add(three1);lis3.add(three2);
        one test1 = new one();
        test1.test(lis1);
        test1.test(lis2);
        test1.test(lis3);
    }
}

abstract class father{
    private int a=314,b=4343;
    public abstract void function();
}
class sonOne extends father{
    public void function(){
        System.out.println("one");
    }
}
class sonTwo extends father{
    public void function(){
        System.out.println("two");
    }
}
class sonThree extends father{
    public void function(){
        System.out.println("three");
    }
}

这里for循环应该是list中的元素被取出来以后进行了向上的转型,而又因为方法重写的缘故,所以父类使用的是子类的方法

其他

注意下我们平常写class的时候要认识清楚这个表示的是我们要写的是一个class文件,所以你没打算写类的时候不要加class,比如写构造器的时候直接这样就可以了
```
public 类名(){}
```
在强调一下父类变量一旦被设为了private就不能直接通过super.变量名直接访问,可以这么理解,当你使用构造器的时候,一个类的实例才真实存在,那么子类的构造器如果有借助父类的话,那么父类的那一部分的权限访问和子类的另一部分权限访问是不同的,而super在其中就扮演一个内置的父类的一个作用.
注意下compareTo(类变量)中的那个类是所属的这个类名

2022.1.28

泛型

自定义泛型类

public class two <E>{
    private E a;
    public two(E a) {
        this.a = a;
    }

    public E getA() {
        return a;
    }
    public static void main(String[] args){
        two<Integer> one = new two<Integer>(313);
        System.out.println("a = "+one.getA());
        two<Float> two = new two<Float>(313.0f);
        System.out.println("two = "+two.getA());
        two three = new two(434324);
        System.out.println("three = "+three.getA());
    }
}

其中E表示待定的数据类型,并且记住,第一行后面一定跟不然会无效,然后注意自定义泛型类中可以不存在E

public class two<E> {
    private int a;
    public two(int a) {
        this.a = a;
    }

    public int getA() {
        return a;
    }
    public static void main(String[] args){
        two<Integer> one = new two<Integer>(313);
        System.out.println("a = "+one.getA());
        two<Float> two = new two<Float>(313);
        System.out.println("two = "+two.getA());
        two three = new two(434324);
        System.out.println("three = "+three.getA());
    }
}

然后如果想传入多个提前不清楚的类的话,可以这么写,使得输入更*

public class two<E,y> {
    private E a ,b;
    public two(E a) {
        this.a = a;
    }

    public E getA() {
        return a;
    }
    public static void main(String[] args){
        two<Integer,Float> one = new two<Integer,Float>(313);
        System.out.println("a = "+one.getA());
        two<Float,Integer> two = new two<Float,Integer>(313);
        System.out.println("two = "+two.getA());
        two three = new two(434324);
        System.out.println("three = "+three.getA());
    }
}

有关于泛型自定义方法

public class two<E,y> {
    public<t> void print(t a){
        System.out.println(a);
    }
    public  static void main(String[] args){
        two one = new two();
        one.print(3132);
        one.print(2133.432f);
        one.print("hello world");
    }
}

如果想约束方法中的t,可以在写成这样

public class two<E,y> {
    public<t extends Number> void print(t a){
        System.out.println(a);
    }
    public  static void main(String[] args){
        two one = new two();
        one.print(3132);
        one.print(2133.432f);
        one.print("hello world");
    }
}

这样正常来说你的第九行应该是错的无法编译

线程

Thread

先了解下什么叫异步执行什么叫同步执行

同步，或同步意思是“连接”，或“依赖”在某种程度上。换句话说，两个同步任务必须彼此了解，一个任务必须以依赖于另一个任务的方式执行，例如等到另一个任务完成后才开始。

异步意味着它们是完全独立的，无论是在初始化还是在执行中，两者都不能以任何方式考虑另一个.

简单来说,同步应该是上面执行完了就可以才能执行下面,而异步就是上面没执行完下面也可以执行
然后来认识下start和run

.start()会导致run()方法被调用，run()方法中的内容称为线程体，它就是这个线程需要执行的工作。

用start()来启动线程，实现了真正意义上的启动线程，此时会出现异步执行的效果，即在线程的创建和启动中所述的随机性。
而如果使用run()来启动线程，就不是异步执行了，而是同步执行，不会达到使用线程的意义

版权声明：本文为CSDN博主「smileTimLi」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_35275233/article/details/87896475

其他

看着泛型类忽然想到一个不相干的东西,就是类的构造器,提前看effective java 的时候看到他说最好不要用构造器要用名字,我提前一直没想明白为什么,因为我以为他说的是变量名,现在想想是因为可以根据构造器的不同排列顺序,参数的多少以及参数的种类来返回对象,但这样就不得不记住参数表了
1、一次性添加多行注释的快捷键

首先选中要注释区域，然后

ctrl+/ 这个是多行代码分行注释，每行一个注释符号

ctrl+shift+/ 这个是多行代码注释在一个块里，只在开头和结尾有注释符号

2、取消多行注释快捷键

怎样添加快捷键的，用相同方法取消，

如 ctrl+/ 添加注释，则ctrl+/取消注释

ctrl+shift+/添加注释，则ctrl+shift+/取消注释
不知道有没有人和我一样,买的联想电脑,F1-F12都有默认选项,如果想不使用默认键盘设置,可以fn+esc,然后我还有个罗技的键盘………F1-F12也有默认选项…….这个的解决方案就是按fn…一直按fn,直到操作完成.还有一种是下软件,但我懒.

2022.1.29

线程

start方法

package xiancheng;

public class one extends Thread{
    public void run() {
        for(int i= 0;i<321;i++)
            System.out.println("jsakdjk");
    }

    public static void main(String[] args){
        System.out.println("main is one ");
        one first = new one();
        first.start();
        //first.start();
        System.out.println("main is two");
    }
}

sleep方法

public class one extends Thread{
    private String a;
    public one (String a) {
        this.a = a;
    }
    public void run() {
        for(int i= 0;i<21;i++){
            System.out.println(a+i);
            try {
                Thread.sleep(6766878);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        one first = new one("this is one");
        one second = new one("this is two");
        first.start();
        //first.start();
    }
}

最开始没加括号,直接完成了我直接懵逼了

然后这个可以用来干刷新的工作

join方法

public class one extends Thread{
    private String a;
    public one (String a) {
        this.a = a;
    }
    public void run() {
        for(int i= 0;i<21;i++){
            System.out.println(a+i);
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        one first = new one("this is one");
        one second = new one("this is two");
        first.start();
        try{
            first.join(10000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        second.start();
        //first.start();
    }
}

利用join方法可以直接优先运行线程,若()里没有参数,则直到该线程运行完才运行下一个线程,若有参数,则运行参数内的时间然后*竞争cpu的使用权

线程优先级

优先级常量(范围1到10,超出报错),注意下优先级不能保证哪个线程一定先执行

获取和设置线程优先级的方法

package xiancheng;

public class one extends Thread{
    private String a;
    public one (String a) {
        this.a = a;
    }
    public void run() {
        for(int i= 0;i<21;i++){
            System.out.println(a+i);
            try {
                Thread.sleep(500);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        one first = new one("this is one");
        one second = new one("this is two");
        int mainPriority =Thread.currentThread().getPriority();
        System.out.println("主线程的优先级为:"+mainPriority);
        first.setPriority(MIN_PRIORITY);
        second.setPriority(MAX_PRIORITY);
        first.start();
        try{
            first.join(10000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("主线程的优先级为:"+mainPriority);
        second.start();
        System.out.println("first的优先级为:"+first.getPriority());
        System.out.println("second的优先级为:"+second.getPriority());
    }
}

2022.1.30

on java 8读书笔记(摘录)

1. 有时候我们会将两者加以区分，将类型（type）定义为接口，而类（class）则是接口的具体实现。
2. 对象能够接受什么请求，是由它的“接口”（interface）决定的，而对象所归属的类定义了这些接口。
3. 接口定义了你能够向这个对象发送的请求。此外，也必然存在一些代码用于响应这些请求。这些代码再加上隐藏的数据，叫作“实现”（implementation）。

线程

同步

先来看下不同步如果出现了线程中断会发生什么


public class Test {
    public static void main(String[] args) {
        two a = new two("jafsdkl",10000);

        Get get = new Get(a);
        Pay pay = new Pay(a);
        get.start();
        pay.start();
        try{
            get.join();
        }catch(Exception e){
            e.printStackTrace();
        }
        try{
            pay.join();
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(a);
    }
}

package xiancheng;

public class two {
    private String name;
    private int account;

    public two(String name, int account) {
        this.name = name;
        this.account = account;
    }

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

    public String getName() {
        return name;
    }

    public int getAccount() {
        return account;
    }

    public void setAccount(int account) {
        this.account = account;
    }

    public void pay(){
        int account = getAccount();
        account-=100;
        try {
            Thread.sleep(212);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("now the account is "+account);
        this.account = account;
    }

    public void get(){
        int account = getAccount();
        account +=500;
        try{
            Thread.sleep(212);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        this.account = account;
        System.out.println("now the account is "+account);
    }

    @Override
    public String toString() {
        return "two{" +
                "name='" + name + '\'' +
                ", account=" + account +
                '}';
    }
}
class Pay extends Thread{
    private two a;
    public Pay(two a) {
        this.a = a;
    }
    public void run() {
        a.pay();
    }
}
class Get extends Thread{
    private two a;
    public Get(two a){
        this.a=a;
    }
    public void run(){
        a.get();
    }
}

.println("now the account is "+account);
}

      @Override
      public String toString() {
          return "two{" +
                  "name='" + name + '\'' +
                  ", account=" + account +
                  '}';
      }
  }
  class Pay extends Thread{
      private two a;
      public Pay(two a) {
          this.a = a;
      }
      public void run() {
          a.pay();
      }
  }
  class Get extends Thread{
      private two a;
      public Get(two a){
          this.a=a;
      }
      public void run(){
          a.get();
      }
  }
  ```

  将上面的代码复制到自己的电脑上,相信你会发现问题,在我的电脑上,如果一切正常的话,最后输出的应该是10400,但是如果我用thread模拟一下抢占线程执行的话,我得到了10500还有9900.

码农公寓

文章目录

2022.1.25

Map

2022.1.26

排序

Comparator接口

Comparable接口

其他

Description

Syntax

Parameters

Return Value