精华内容
下载资源
问答
  • 一.object类 ...object一共11个方法,这里先说两个常用的两个 一.tostring()方法 Public String toString()返回字符串表示。 就是对象的类型+内存地址值 Person p = new Person("张三",18); ...

    一.object类

    概述:
    object类是java中的根类,就是所有类的父类,每一个对象的创建都默认继承了object类。
    object一共11个方法,这里先说两个常用的两个
    一.tostring()方法
    Public String toString()返回字符串表示。
    就是对象的类型+内存地址值

            Person p = new Person("张三",18);
            String s = p.toString();
            System.out.println(s);//com.itheima.demo01.Object.Person@75412c2f | abc | Person{name=张三 ,age=18}
    //直接打印对象的名字,其实就是调用对象的toString  p=p.toString();
            System.out.println(p);//com.itheima.demo01.Object.Person@5f150435 | abc | Person{name=张三 ,age=18}
    

    直接调用toString()对象,其实打印出来的就是地址值,但是我们在实际操作中不打印其地址值,一般都是直接打印对象的属性值所以我们需要重写toString()方法。
    1.自己重写toSting()方法

    /*
            直接打印对象的地址值没有意义,需要重写Object类中的toString方法
            打印对象的属性(name,age)
         */
        @Override
        public String toString() {
           //return "abc";
           return "Person{name="+name+" ,age="+age+"}";
        }
    

    2.我们使用idea的话可以使用Alt+ins,直接重写方法也是一样的。

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

    二.Equals方法
    equals方法是比较两个对象或者是两个属性值是否相同
    但是Object类的equals方法,默认比较的是两个对象的地址值,没有意义,所以我们要重写equals方法,比较两个对象的属性(name,age)
    问题:
    隐含着一个多态
    多态的弊端:无法使用子类特有的内容(属性和方法)
    Object obj = p2 = new Person(“古力娜扎”,19);
    解决:可以使用向下转型(强转)把obj类型转换为Person
    1.自行重写

    @Override
        public boolean equals(Object obj) {
            //增加一个判断,传递的参数obj如果是this本身,直接返回true,提高程序的效率
            if(obj==this){
                return true;
            }
    
            //增加一个判断,传递的参数obj如果是null,直接返回false,提高程序的效率
            if(obj==null){
                return false;
            }
    
            //增加一个判断,防止类型转换一次ClassCastException
            if(obj instanceof Person){
                //使用向下转型,把obj转换为Person类型
                Person p = (Person)obj;
                //比较两个对象的属性,一个对象是this(p1),一个对象是p(obj->p2)
                boolean b = this.name.equals(p.name) && this.age==p.age;
                return b;
            }
            //不是Person类型直接返回false
            return false;
        }
    

    2.我们使用idea的话,也可以直接使用alt+ins
    点开之后我们可以选择默认版本和7版本
    默认版本:

     @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
    
            Person person = (Person) o;
    
            if (age != person.age) return false;
            return name != null ? name.equals(person.name) : person.name == null;
        }
    

    7版本(推荐使用):

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

    这个7版本中使用 了objects类

    关于objects类
    JDK7添加了一个Objects工具类,它提供了一些方法来操作对象,它由一些静态的实用方法组成,这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的),用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

    在比较两个对象的时候,Object的equals方法容易抛出空指针异常,而Objects类中的equals方法就优化了这个问题。方法如下:

    • public static boolean equals(Object a, Object b):判断两个对象是否相等。

    这个类可以防止抛出空指针异常

    日期时间类:

    一.Date类
    Date类就是时间,表示特定的瞬间,精确到毫秒
    这个类里面拥有着多个构造方法但是很多都已经过时了,所以只学习三个就可以了。
    方法:
    1.public Date() 这个方法是初始化的意思,就是可以将我们本地的时间显示出来

    /*
            Date类的空参数构造方法
            Date() 获取当前系统的日期和时间
         */
        private static void demo01() {
            Date date = new Date();
            System.out.println(date);//Sun Aug 08 12:23:03 CST 2088
        }
    

    2.public Date(long date) Date类的带参构造方法 这个方法表示分配Date对象并初始化此对象,以表示自从标准基准时间(称为“历元(epoch)”,即1970年1月1日00:00:00 GMT)以来的指定毫秒数。简单来说就是将毫秒数转化为时间。

    /*
            Date类的带参数构造方法
            Date(long date) :传递毫秒值,把毫秒值转换为Date日期
         */
        private static void demo02() {
            Date date = new Date(0L);
            System.out.println(date);// Thu Jan 01 08:00:00 CST 1970
    
            date = new Date(3742767540068L);
            System.out.println(date);// Sun Aug 08 09:39:00 CST 2088
        }
    

    3.public long getTime() 把日期对象转换成对应的时间毫秒值。 和上面的带参构造相反 这个是Date类的无参构造方法。

    /*
            long getTime() 把日期转换为毫秒值(相当于System.currentTimeMillis()方法)
              返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
         */
        private static void demo03() {
            Date date = new Date();
            long time = date.getTime();
            System.out.println(time);//3742777636267
        }
    

    注意
    *把日期转换为毫秒:
    当前的日期:2088-01-01
    时间原点(0毫秒):1970 年 1 月 1 日 00:00:00(英国格林威治)
    就是计算当前日期到时间原点之间一共经历了多少毫秒 (3742767540068L)
    注意:
    中国属于东八区,会把时间增加8个小时
    1970 年 1 月 1 日 08:00:00

    把毫秒转换为日期:
        1 天 = 24 × 60 × 60 = 86400 秒  = 86400 x 1000 = 86400000毫秒*
    

    2.DateFormat类
    java.text.DateFormat是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。
    由于DateFormat为抽象类,不能直接使用,所以需要常用的子类
    作用:
    格式化(也就是日期 -> 文本)、解析(文本-> 日期)
    成员方法:
    1.String format(Date date) 按照指定的模式,把Date日期,格式化为符合模式的字符串
    2.Date parse(String source) 把符合模式的字符串,解析为Date日期
    DateFormat类是一个抽象类,无法直接创建对象使用,可以使用DateFormat类的子类
    参数pattern是一个字符串,代表日期时间的自定义格式。
    使用DateFormat类中的方法parse,把文本解析为日期
    使用步骤:

    1.创建SimpleDateFormat对象,构造方法中传递指定的模式
    2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
    注意:
    public Date parse(String source) throws ParseException
    parse方法声明了一个异常叫ParseException
    如果字符串和构造方法的模式不一样,那么程序就会抛出此异常
    调用一个抛出了异常的方法,就必须的处理这个异常,要么throws继续抛出这个异常,要么try catch自己处理

    private static void demo02() throws ParseException {
            //1.创建SimpleDateFormat对象,构造方法中传递指定的模式
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
            //2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
            //Date parse(String source)  把符合模式的字符串,解析为Date日期
            Date date = sdf.parse("2088年08月08日 15时51分54秒");
            System.out.println(date);
        }
    

    格式规则

    常用的格式规则为:

    标识字母(区分大小写) 含义
    y
    M
    d
    H
    m
    s
    l 毫秒

    使用DateFormat类中的方法format,把日期格式化为文本
    使用步骤:
    1.创建SimpleDateFormat对象,构造方法中传递指定的模式
    2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)

    private static void demo01() {
            //1.创建SimpleDateFormat对象,构造方法中传递指定的模式
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
            //2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
            //String format(Date date)  按照指定的模式,把Date日期,格式化为符合模式的字符串
            Date date = new Date();
            String d = sdf.format(date);
            System.out.println(date);//Sun Aug 08 15:51:54 CST 2088
            System.out.println(d);//2088年08月08日 15时51分54秒
        }
    

    看了这么多有点懵,试一下这一道题
    练习:
    请使用日期时间相关的API,计算出一个人已经出生了多少天。
    分析:
    1.使用Scanner类中的方法next,获取出生日期
    2.使用DateFormat类中的方法parse,把字符串的出生日期,解析为Date格式的出生日期
    3.把Date格式的出生日期转换为毫秒值
    4.获取当前的日期,转换为毫秒值
    5.使用当前日期的毫秒值-出生日期的毫秒值
    6.把毫秒差值转换为天(s/1000/60/60/24)

    public class Demo02Test {
        public static void main(String[] args) throws ParseException {
            //1.使用Scanner类中的方法next,获取出生日期
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入您的出生日期,格式:yyyy-MM-dd");
            String birthdayDateString = sc.next();
            //2.使用DateFormat类中的方法parse,把字符串的出生日期,解析为Date格式的出生日期
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date birthdayDate = sdf.parse(birthdayDateString);
            //3.把Date格式的出生日期转换为毫秒值
            long birthdayDateTime = birthdayDate.getTime();
            //4.获取当前的日期,转换为毫秒值
            long todayTime = new Date().getTime();
            //5.使用当前日期的毫秒值-出生日期的毫秒值
            long time = todayTime-birthdayDateTime;
            //6.把毫秒差值转换为天(s/1000/60/60/24)
            System.out.println(time/1000/60/60/24);
        }
    

    3.Calendar类
    日历我们都是见过的,calender就是日历类 获取的日历的时间电脑上本身就有的
    Calendar类是一个抽象类,里边提供了很多操作日历字段的方法(YEAR、MONTH、DAY_OF_MONTH、HOUR )
    Calendar类无法直接创建对象使用,里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
    static Calendar getInstance() 使用默认时区和语言环境获得一个日历。

    public class Demo01Calendar {
        public static void main(String[] args) {
            Calendar c = Calendar.getInstance();//多态
            System.out.println(c);
        }
    

    西方的月份是0-11
    常用的方法

    • public int get(int field):返回给定日历字段的值。
    • public void set(int field, int value):将给定的日历字段设置为给定值。可以同时设置
    • public abstract void add(int field, int amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量。
    • public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
      int field:日历类的字段,可以使用Calendar类的静态成员变量获取
      public static final int YEAR = 1; 年
      public static final int MONTH = 2; 月
      public static final int DATE = 5; 月中的某一天
      public static final int DAY_OF_MONTH = 5;月中的某一天
      public static final int HOUR = 10; 时
      public static final int MINUTE = 12; 分
      public static final int SECOND = 13; 秒

    返回给定的日历字段名

    /*
            public int get(int field):返回给定日历字段的值。
            参数:传递指定的日历字段(YEAR,MONTH...)
            返回值:日历字段代表的具体的值
         */
        private static void demo01() {
            //使用getInstance方法获取Calendar对象
            Calendar c = Calendar.getInstance();
            int year = c.get(Calendar.YEAR);
            System.out.println(year);
    
            int month = c.get(Calendar.MONTH);
            System.out.println(month);//西方的月份0-11 东方:1-12
            //月份中的某一天
    
            //int date = c.get(Calendar.DAY_OF_MONTH);
            int date = c.get(Calendar.DATE);
            System.out.println(date);
        }
    

    将给定的日历字段设置为定值

    /*
            public void set(int field, int value):将给定的日历字段设置为给定值。
            参数:
                int field:传递指定的日历字段(YEAR,MONTH...)
                int value:给指定字段设置的值
         */
        private static void demo02() {
            //使用getInstance方法获取Calendar对象
            Calendar c = Calendar.getInstance();
    
            //设置年为9999
            c.set(Calendar.YEAR,9999);
            //设置月为9月
            c.set(Calendar.MONTH,9);
            //设置日9日
            c.set(Calendar.DATE,9);
    
            //同时设置年月日,可以使用set的重载方法
            c.set(8888,8,8);
    
            int year = c.get(Calendar.YEAR);
            System.out.println(year);
    
            int month = c.get(Calendar.MONTH);
            System.out.println(month);//西方的月份0-11 东方:1-12
    
            int date = c.get(Calendar.DATE);
            System.out.println(date);
        }
    

    根据日历的规则,为给定的日历字段添加或减去指定的时间量。

     /*
            public abstract void add(int field, int amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量。
            把指定的字段增加/减少指定的值
            参数:
                int field:传递指定的日历字段(YEAR,MONTH...)
                int amount:增加/减少指定的值
                    正数:增加
                    负数:减少
         */
        private static void demo03() {
            //使用getInstance方法获取Calendar对象
            Calendar c = Calendar.getInstance();
    
            //把年增加2年
            c.add(Calendar.YEAR,2);
            //把月份减少3个月
            c.add(Calendar.MONTH,-3);
    
    
            int year = c.get(Calendar.YEAR);
            System.out.println(year);
    
            int month = c.get(Calendar.MONTH);
            System.out.println(month);//西方的月份0-11 东方:1-12
    
            //int date = c.get(Calendar.DAY_OF_MONTH);
            int date = c.get(Calendar.DATE);
            System.out.println(date);
        }
    

    返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。

      private static void demo04() {
            //使用getInstance方法获取Calendar对象
            Calendar c = Calendar.getInstance();
    
            Date date = c.getTime();
            System.out.println(date);
        }
    
    

    小贴士:

     西方星期的开始为周日,中国为周一。
    
     在Calendar类中,月份的表示是以0-11代表1-12月。
    
     日期是有大小关系的,时间靠后,时间越大。
    

    三.system类

    java.lang.System类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作,在System类的API文档中,常用的方法有:

    • public static long currentTimeMillis():返回以毫秒为单位的当前时间。可以用来测试程序运行的时间
      /*
            public static long currentTimeMillis():返回以毫秒为单位的当前时间。
            用来测试程序的效率
            验证for循环打印数字1-9999所需要使用的时间(毫秒)
         */
        private static void demo01() {
            //程序执行前,获取一次毫秒值
            long s = System.currentTimeMillis();
            //执行for循环
            for (int i = 1; i <=9999 ; i++) {
                System.out.println(i);
            }
            //程序执行后,获取一次毫秒值
            long e = System.currentTimeMillis();
            System.out.println("程序共耗时:"+(e-s)+"毫秒");//程序共耗时:106毫秒
        }
    
    • public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length):将数组中指定的数据拷贝到另一个数组中。
    /*
            public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length):将数组中指定的数据拷贝到另一个数组中。
            参数:
                src - 源数组。
                srcPos - 源数组中的起始位置(起始索引)。
                dest - 目标数组。
                destPos - 目标数据中的起始位置。
                length - 要复制的数组元素的数量。
            练习:
                将src数组中前3个元素,复制到dest数组的前3个位置上
                    复制元素前:
                    src数组元素[1,2,3,4,5],dest数组元素[6,7,8,9,10]
                    复制元素后:
                    src数组元素[1,2,3,4,5],dest数组元素[1,2,3,9,10]
         */
        private static void demo02() {
            //定义源数组
            int[] src = {1,2,3,4,5};
            //定义目标数组
            int[] dest = {6,7,8,9,10};
            System.out.println("复制前:"+ Arrays.toString(dest));
            //使用System类中的arraycopy把源数组的前3个元素复制到目标数组的前3个位置上
            System.arraycopy(src,0,dest,0,3);
            System.out.println("复制后:"+ Arrays.toString(dest));
        }
    

    第四章 StringBuilder

    1.字符串的拼接问题
    字符串的内容是不可变的,底层的实现是一个final修饰的数组,每一次进行字符串拼接的时候,都会在内存中创建一个新的对象

    p
    ublic class StringDemo {
    public static void main(String[] args) {
    String s = "Hello";
    s += "World";
    System.out.println(s);
    }
    }
    

    在API中说字符串,字符串是一个常量,他们的值在创建后就不能更改了
    根据这句话分析我们的代码,其实总共产生了三个字符串,即 “Hello” 、 “World” 和 “HelloWorld” 。引用变量s
    首先指向 Hello 对象,最终指向拼接出来的新字符串对象,即 HelloWord 。

    2.StringBuilder类
    因为string字符串效率低下,故此使用StringBuilder来实现提高效率

    java.lang.StringBuilder类:字符串缓冲区,可以提高字符串的效率
    构造方法:
    StringBuilder() 构造一个不带任何字符的字符串生成器,其初始容量为 16 个字符。(声明但是不复制)
    StringBuilder(String str) 构造一个字符串生成器,并初始化为指定的字符串内容。(声明且赋初始值)

    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
        }
    }
    

    **StringBuilder的常用方法:
    给无参的构造方法添加数据
    public StringBuilder append(…):添加任意类型数据的字符串形式,并返回当前对象自身。

     public static void main(String[] args) {
            //创建StringBuilder对象
            StringBuilder bu = new StringBuilder();
            //使用append方法往StringBuilder中添加数据
            //append方法返回的是this,调用方法的对象bu,this==bu
            //StringBuilder bu2 = bu.append("abc");//把bu的地址赋值给了bu2
            //System.out.println(bu);//"abc"
            //System.out.println(bu2);//"abc"
            //System.out.println(bu==bu2);//比较的是地址 true
    
            //使用append方法无需接收返回值
    //        bu.append("abc");
    //        bu.append(1);
    //        bu.append(true);
    //        bu.append(8.8);
    //        bu.append('中');
    //        System.out.println(bu);//abc1true8.8中
    
            /*
                链式编程:方法返回值是一个对象,可以继续调用方法
             */
            System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase());
            bu.append("abc").append(1).append(true).append(8.8).append('中');
            System.out.println(bu);//abc1true8.8中
    
        }
    

    String 和 Stringbuliter可以相互转换

    /*
        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);
        }
    }
    

    注意:
    append方法不用接受返回值
    链式编程就是可以联系添加不用一个一个添加
    stringBuliter 已经覆盖重写了tostring方法

    第五章 包装类

    1.什么是包装类?
    基本数据类型的数据,使用起来非常的方便,但是没有对应的方法来操作这些数据,所以我们可以用一个类,把基本的数据类型来包装起来,这个类就是包装类,在包装类中的可以定义一个方法,用来操作这些数据
    基本类型 对应的包装类(位于java.lang包中)

    基本类型 对应的包装类(位于java.lang包中)
    byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double
    char Character
    boolean Boolean

    2.拆箱和装箱
    装箱:把基本数据类型的数据,包装到类中,(基本数据类型》包装类)
    构造方法:
    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) {
            //装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
            //构造方法
            //放int类型的
            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);
    
            //Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化异常
            Integer in4 = Integer.valueOf("1");
            System.out.println(in4);
    
            //拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
            int i = in1.intValue();
            System.out.println(i);
    
    

    3.自动装箱与自动拆箱:
    基本类型的数据和包装类之间可以自动的相互转换
    JDK1.5之后出现的新特性

     public static void main(String[] args) {
            /*
                自动装箱:直接把int类型的整数赋值包装类
                Integer in = 1; 就相当于 Integer in = new Integer(1);
             */
            Integer in = 1;
    
            /*
                自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算
                in+2;就相当于 in.intVale() + 2 = 3
                in = in.intVale() + 2 = 3 又是一个自动装箱
             */
            in = in+2;
    
            ArrayList<Integer> list = new ArrayList<>();
            /*
                ArrayList集合无法直接存储整数,可以存储Integer包装类
             */
            list.add(1); //-->自动装箱 list.add(new Integer(1));
    
            int a = list.get(0); //-->自动拆箱  list.get(0).intValue();
        }
    

    注意:
    ArrayList集合无法直接存储整数,可以存储Integer包装类

    4.基本类型与字符串类型之间的相互转换的方法:
    基本类型->字符串(String)
    1.基本类型的值+"" 最简单的方法(工作中常用)
    2.包装类的静态方法toString(参数),不是Object类的toString() 重载
    static String toString(int i) 返回一个表示指定整数的 String 对象。
    3.String类的静态方法valueOf(参数)
    static String valueOf(int i) 返回 int 参数的字符串表示形式。
    字符串(String)->基本类型
    使用包装类的静态方法parseXXX(“字符串”);
    Integer类: static int parseInt(String s)
    Double类: static double parseDouble(String s)

     public static void main(String[] args) {
            //基本类型->字符串(String)
            int i1 = 100;
            String s1 = i1+"";
            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
    
            //字符串(String)->基本类型
            int i = Integer.parseInt(s1);
            System.out.println(i-10);
    
            int a = Integer.parseInt("a");//NumberFormatException
            System.out.println(a);
        }
    

    总结:
    在这里插入图片描述
    以上内容皆为黑马教程自己做的笔记,侵权删!

    展开全文
  • 前言最近产品升级大版本,准备把技术和开发工具都换一下,团队其他人都在研究前后端各种开发工具,我先尝试一波idea(2019.3.2版本),看看如何更好使用它,本文我是在研究1天后记录一些优化配置项,纯干货,这...

    前言

    最近产品升级大版本,准备把技术和开发工具都换一下,团队其他人都在研究前后端的各种开发工具,我先尝试一波idea(2019.3.2版本),

    看看如何更好的使用它,本文我是在研究1天后记录的一些优化配置项,纯干货,这篇文章会持续更新...

    界面优化配置

    等宽字体设置

    Settings -> Editor -> Font

    默认已经勾选只显示等宽字体,在这里可以选择自己喜欢的字体

    b8955f64791a38276927403bdad6689d.png

    屏蔽非代码相关目录文件

    屏蔽 eclipse 相关目录,.idea文件夹,iml文件,pom.xml.versionsBackupmaven(maven版本备份文件)

    修改前效果

    a95907a9a4b572cf488ce4b9dce6faed.png

    Settings > File Types > ignore files and folders 修改为以下配置

    *.hprof;*.pyc;*.pyo;*.rbc;*.yarb;*~;.DS_Store;.git;.hg;.svn;CVS;__pycache__;_svn;vssver.scc;vssver2.scc;*.iml;.classpath;.project;pom.xml.versionsBackup;.idea;.settings;

    48a66cc2cb2c6bbe365814eb4ea00803.png

    tabs多行显示

    Settings -> Editor -> General ->Editors Tabs

    2e5d0ee2cf72642edf4f484e04da7f59.png

    修改后效果

    9eb8dd9af3623acd2332d6a49c4af90e.png

    使用ctrl+滑轮调整字体大小

    Settings -> Editor -> General

    134c1bf75119fbbde5e7b7a1c339b2e2.png

    编码相关优化配置

    文件默认编码格式

    修改前效果

    dcb192f026e456305ab7001ad1fcd1a2.png

    Settings -> Editor -> File Encodings

    36b06a764346c5af4f35dd785bc0b66a.png

    java 代码中 import和method 默认全部展开

    修改前效果

    f523d4ff0c5000d11e4e3e972d04921f.png

    Settings -> Editor -> Code folding

    ff6ab566c3240265ee02a2bc05a514a0.png

    java 代码中tab替换空格

    Settings -> Editor -> Code Style -> Java

    3604659de23c1e96ae7c30a76a929ff9.png

    java 代码中 显示空格

    Settings -> Editor -> General -> Appearance

    7221245c2638a283517d1326ac9626ea.png

    自动删除代码末尾空格

    Settings -> Editor -> General

    71d7636e8ba3f60ea3a8aa0fda539223.png

    修改过的代码留下高亮线

    修改前效果

    7062569def8a51cfc5f4ce4d72ec9377.png

    Settings -> Editor -> General

    afcefd9c8b2488e3c2eb9663fed057e8.png

    自动提示大小写不敏感

    Settings -> Editor -> General -> Code Completion

    4f7bbc0fce59c3ef5c8d52370fda4e64.png

    修改后效果

    8b49ad52f215f6b2baf602eb8b89bf43.png

    自动导包功能开启

    Settings -> Editor -> General -> Auto Import

    f3f9f86e9551c90d50fee5780282792c.png

    Insert imports on paste

    设置为 "all",表示当复制粘贴程序代码时,会自动import需要的包。

    Optimize imports on the fly

    勾选表示会动态优化import内容,自动删除多余或重复的import。

    Add unambiguous imports on the fly

    勾选表示会自动加入明确的(类库中只有一种选择)import,即使我手动删除,还是会自动帮我添加回来。

    代码自动同步和保存机制

    Settings -> Appearance&Behavior -> System Settings

    6c5f46014845b44efc5d6a73ce9d662c.png

    导入eclipse的code style

    Settings -> Editor -> Code Style -> Java

    导入eclipse的code style文件

    c647462b35d081a8824cdb095e4f0f1d.png

    设置sql代码格式,自动格式化sql语句

    首先设置数据库语言

    Settings -> Languages & Frameworks -> SQL Dialects

    21bfcaa67343b07b021f9788ab21a09d.png

    然后修改sql语句格式(我使用的oracle)

    Settings -> Editor -> Code Style -> SQL -> Oracle

    e9399621cbf399b3a91a636a44449ebc.png

    在代码中使用后的效果(以mybatis mapper文件为例)

    f9b0beba041a979c82db19a745fa6c66.png

    插件相关

    自动保存触发自动format(Save Actions)

    安装Save Actions插件

    8315deefc52a52def87dc6a8d6468f8f.png

    Settings -> Other Settings -> Save Actions

    2df7e34d35136f885a287e87645d4fcb.png

    推荐使用 Reformat only changed code

    展开全文
  • ❝完全开源淘客项目:https://github.com/silently9527/mall-coupons-server微信公众号:贝塔学Java❞前言自己在开发过程中经常会使用一些...

    完全开源的淘客项目:https://github.com/silently9527/mall-coupons-server

    微信公众号:贝塔学Java

    前言

    自己在开发的过程中经常会使用一些在线的工具,比如:时间戳转日期,JSON格式化等等;前几天思考了下想把这些常用的功能都做成IDEA插件,在使用的时候就不用去网上寻找工具,在IDEA中就可以快速完成提升开发人员开发效率,所以就熬夜肝了这个插件,欢迎大家都来使用。

    Github地址: https://github.com/silently9527/ToolsetIdeaPlugin

    Gitee地址: https://gitee.com/silently9527/ToolsetIdeaPlugin

    觉得好用的小伙伴记得小手一抖 star 哟

    版本更新

    • 修复了大家反馈的一些问题

    • 新增了md5加密功能

    • 新增了生成二维码,下载二维码,插入logo功能

    • 弹窗位置从右侧改到了下边

    已实现功能

    • SQL 转换成 ElasticSearch 查询语句

    • 正则表达式

    • Base64编码/解码

    • JSON格式化

    • URL编码/解码

    • 手机号归属地

    • IP地址

    • 日期时间戳互转

    • MD5

    • 生成二维码

    计划中的功能

    • Cron表达式

    • 图片base64编码

    • UUID生成器

    • 文件下载

    • js/css混淆压缩

    • 标签页支持手动设置

    点关注,不迷路

    「白嫖不好,创作不易」,希望朋友们可以「点赞评论关注」三连,因为这些就是我分享的全部动力来源????

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 345
精华内容 138
关键字:

java常用的idea版本

java 订阅