java基础学习笔记（三）

梦里梦外; 2021-09-18 11:00 555阅读 0赞

1、装箱和拆箱

所有基本类型都有对应的类类型，比如int对应的类是Integer,这种类就叫做封装类。数字封装类有Byte、Short、Integer、Long、Float、Double这些类都是抽象类Number的子类。封装类和基本类型之间可以相互转换，而基本类型自动转封装类型就叫装箱，反之则是拆箱，代码如下

  1. int i = 5;
  2.         //基本类型转换成封装类型
  3.         Integer it = new Integer(i);
  5.         //自动转换就叫装箱，通过=符号
  6.         Integer it2 = i;
  8.         //Integer是Number的子类，所以打印true
  9.         System.out.println(it instanceof Number);
  11.         //封装类型转换成基本类型
  12.         int i2 = it.intValue();

2、字符串转换：数字转字符串：方法一使用String 类的静态方法valueOf(); 方法二是把基本类型装箱为封装类型，然后调用封装类类型的toString();

  1. int i = 5;
  2.       String str = String.valueOf(i);//方法一使用封装类的valueOf方法
  3.       Integer it = i;  //自动转换装箱
  4.       String str2 = it.toString(); //调用字符串封装类的toString方法

3、数学方法：java.lang.Math提供了一些常用的数学运算方法，并且都是以静态方法的形式存在。如Math.round()是四省五入，Math.sqrt(9)是开平方，Math.pow(2,4)是2的4次方，Math.E是自然常数。

4、格式化输出：输出时如果变量过多时会用字符串拼接，拼接会显得繁琐，另一种解决方式是格式化输出，printf和format能够达到一模一样的效果，其中%s表示字符串，%d表示数字，%n表示换行。如下：

  1. String sentenceFormat="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";
  2. System.out.printf(sentenceFormat, "teemo", 5,"超神");
  3. System.out.format(sentenceFormat, "teemo", 5,"超神");

5、Char基本类型对应的封装类型是Character，Character常用静态方法如下：

  1. System.out.println(Character.isLetter('a'));//判断是否为字母
  2.         System.out.println(Character.isDigit('a')); //判断是否为数字
  3.         System.out.println(Character.isWhitespace(' ')); //是否是空白
  4.         System.out.println(Character.isUpperCase('a')); //是否是大写
  5.         System.out.println(Character.isLowerCase('a')); //是否是小写
  7.         System.out.println(Character.toUpperCase('a')); //转换为大写
  8.         System.out.println(Character.toLowerCase('A')); //转换为小写
  10.         String a = 'a'; //不能够直接把一个字符转换成字符串
  11.         String a2 = Character.toString('a'); //转换为字符串

6、字符串使用：String 被修饰为final，所以不能被继承。String的成员变量是private final 的，所以String 是immutable的，表现像个常量。如String s=”abc”;s=”123”;字符串创建的内容并没有改变，s引用指向发生改变了，“abc”和“123”是两个字符串对象，在内存空间上占两个位置。

7、获取随机字符串的多种方法：

ASCII码对照表

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6dW9sdW8_size_16_color_FFFFFF_t_70

方法1，思路是随机获取字母数字ASCII码数对应范围内的数，判断是否是字母或数字，循环获取5个满足要求的字符拼接成字符串

  1. char cs[] = new char[5];
  2.         short start = '0';
  3.         short end = 'z'+1;
  4.         for (int i = 0; i < cs.length; i++) {
  5.             while (true) {
  6.                 char c = (char) ((Math.random() * (end - start)) + start);
  7.                 if (Character.isLetter(c) || Character.isDigit(c)) {
  8.                     cs[i] = c;
  9.                     break;
  10.                 }
  11.             }
  12.         }
  13.         String result = new String(cs);
  14.         System.out.println(result);

方法2，思路是将所有数字、字母字符拼接成一个字符串，再随机获取字符

  1. String pool = "";
  2.         for (short i = '0'; i <= '9'; i++) {
  3.             pool+=(char)i;
  4.         }
  5.         for (short i = 'a'; i <= 'z'; i++) {
  6.             pool+=(char)i;
  7.         }
  8.         for (short i = 'A'; i <= 'Z'; i++) {
  9.             pool+=(char)i;
  10.         }
  11.         char cs2[] = new char[5];
  12.         for (int i = 0; i < cs2.length; i++) {
  13.             int index = (int) (Math.random()*pool.length());
  14.             cs2[i] =  pool.charAt( index );
  15.         }
  16.         String result2 = new String(cs2);
  17.         System.out.println(result2);

方法3：思路是在数字字母分块对应的ASCII码数值间获取随机数，循环多次获取随机数转换成字符拼接成字符串

  1. public class TestNumber {
  3.     public static void main(String[] args) {
  4.         // TODO Auto-generated method stub
  5.         char[] chars = new char[5]; // 创建字符数组，每一个字符都将随机获取
  6.         String str = ""; // 空字符串用来最后组合随机字符的
  7.         for (int i = 0; i < chars.length; i++) {
  8.             chars[i] = getRadomChar();
  9.             str += chars[i];
  10.         }
  11.         System.out.println(str);
  12.     }
  14.     public static char getRadomChar() {
  15.         int m1 = (int) (Math.random() * (90 - 65)) + 65;
  16.         int m2 = (int) (Math.random() * (57 - 48)) + 48;
  17.         int m3 = (int) (Math.random() * (122 - 97)) + 97;
  18.         int[] m = { m1, m2, m3 };
  19.         int index = (int) Math.floor((Math.random() * 3));
  20.         char c = (char) m[index];
  21.         System.out.println(c);
  22.         return c;
  23.     }
  25. }

其中

  1. public static void main(String[] args) {
  2.         //获取拼接好的所有字符
  3.         //在for循环中采用StringBuilder比用String的 `+=`高效;
  4.         StringBuilder strPool_tmp = new StringBuilder();  
  5.         for(short i='0';i<'z';i++) {
  6.             if(Character.isLetter((char)i)||Character.isDigit((char)i)) {
  7.                 strPool_tmp.append((char)i);
  8.             }
  9.         }
  10.         System.out.println(strPool_tmp.toString());
  11.     }

8、穷举法（枚举法）：

枚举法是在分析问题时，逐个列举出所有可能情况，然后根据条件判断此答案是否合适，合适就保留，不合适就丢弃，最后得出一般结论。主要利用计算机运算速度快、精确度高的特点，对要解决问题的所有可能情况，一个不漏地进行检验，从中找出符合要求的答案，因此枚举法是通过牺牲时间来换取答案的全面性。

  1. 说白了，**就是通过循环或者递归，把所有可能的情况过一遍，**符合条件就留下，不符合继续找。

9、递归算法。递归的基本思想是把规模大的问题转化为规模小的相似的子问题来解决。在函数实现时，因为解决大问题的方法和解决小问题的方法往往是同一个方法，所以就产生了调用它自身的情况。递归是利用系统的堆栈保存函数当中的局部变量来解决问题的，因为函数调用的开销，递归常常会带来效率问题。

  1. //斐波拉契数列问题。找出数列中指定index位置的数值  1,1,2,3,5,8,13,21,34,55
  2.     public static int getNum(int testNum) { 
  3.         if(testNum<3) {
  4.             return 1;
  5.         }else {
  6.             return getNum(testNum-1)+getNum(testNum-2);
  7.         }
  8.     }

10、字符串方法：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6dW9sdW8_size_16_color_FFFFFF_t_70 1

charAt(int index)获取指定位置的字符；toCharArray()是将字符串转换为对应的字符数组；subString 截取子字符串；split 根据分隔符进行分隔生成字符串数组；trim 去掉首尾空格后返回新的字符串；toLowerCase 返回全部变成小写 ，toUpperCase 返回全部变成大写的字符串；indexOf 判断字符或者子字符串出现的位置；contains 是否包含子字符串；replaceAll 替换所有的 ，replaceFirst 只替换第一个；

  1. public class TestString {
  3.     public static void main(String[] args) {
  4.         // TODO Auto-generated method stub
  5.         String sentence = "盖伦,在进行了连续8次击杀后,获得了 超神 的称号";
  6.         char c = sentence.charAt(0);
  7.         System.out.println(c);  //输出 盖
  9.         char[] cs = sentence.toCharArray(); //获取对应的字符数组
  10.         System.out.println(sentence.length() == cs.length); 
  12.         //截取从第3个开始的字符串 （基0）
  13.         //到5-1的位置的字符串
  14.         //左闭右开
  15.         String subString2 = sentence.substring(3,5);
  16.         System.out.println(subString2);
  18.         //根据,进行分割，得到3个子字符串
  19.         String subSentences[] = sentence.split(",");
  20.         for (String sub : subSentences) {
  21.             System.out.println(sub);
  22.         }
  24.         System.out.println(sentence.indexOf('8')); //字符第一次出现的位置
  25.         System.out.println(sentence.indexOf("超神")); //字符串第一次出现的位置
  26.         System.out.println(sentence.lastIndexOf("了")); //字符串最后出现的位置
  27.         System.out.println(sentence.indexOf(',',5)); //从位置5开始，出现的第一次,的位置 
  28.         System.out.println(sentence.contains("击杀")); //是否包含字符串"击杀"
  30.         String temp = sentence.replaceFirst(",","");//只替换第一个
  31.         System.out.println(temp);
  32.     }
  34. }

11、比较字符串：

  1. public class TestString {
  3.     public static void main(String[] args) {
  4.         // TODO Auto-generated method stub
  5.         String str="the light";  //编译器碰到字符串的字面值就会创建一个新对象
  6.         String str2=new String();
  7.         String str3="the light";  //当发现已经存在的字符串对象就不会重复创建
  8.         System.out.println(str==str2); //false
  9.         System.out.println(str==str3); //true
  11.         System.out.println(str.equals(str2)); //false,完全一样则返回true
  12.         String str4=str3.toUpperCase();
  13.         System.out.println(str.equalsIgnoreCase(str4)); //true
  15.         String start="th";
  16.         String end="ight";
  17.         System.out.println(str.startsWith(start));//true,是否以字符串开始或结束
  18.         System.out.println(str.endsWith(end));
  19.     }
  21. }

11、StringBuffer可变长的字符串，有以下方法

2019031406475383.png

  1. public static void main(String[] args) {
  2.         String str="the";
  3.         StringBuffer sb=new StringBuffer(str);
  4.         System.out.println(str.length());  //3,String内部是一个字符数组
  5.         System.out.println(sb.capacity());  //19，内部也有一个字符数组，留有冗余数组，19这个空间大小，不同JDK不一样
  6.         sb.append(" Man"); //追加
  7.         sb.insert(7," IS BOY"); //插入
  8.         sb.reverse(); //反转
  9.         System.out.println(sb);
  10. }

12、Date类：注意：是java.util.Date; 而非 java.sql.Date，此类是给数据库访问的时候使用的

时间原点概念：Java中的时间原点，其对应的日期是1970年1月1日 8点0分0秒 。

  1. public static void main(String[] args) {
  3.         Date d1=new Date();   //创建日期对象
  4.         System.out.println("当前日期时间是"+d1);
  6.         // 从1970年1月1日 早上8点0分0秒 开始经历的毫秒数
  7.         Date d2 = new Date(5000);
  8.         System.out.println("从1970年1月1日 早上8点0分0秒 开始经历了5秒的时间");
  9.         System.out.println(d2);
  11.         //getTime()方法得到一个long型的整数
  12.         System.out.println("从时间原点开始经历的毫秒数："+d1.getTime());
  14.         //new Date().getTime() 和 System.currentTimeMillis() 基本是一样的
  15.         System.out.println("系统的当前毫秒数："+System.currentTimeMillis());
  17.     }

13、SimpleDateFormat 日期格式化类，有以下方法

20190314072550532.png

  1. public static void main(String[] args) {
  2.         //日期转字符串
  3.         //y 代表年
  4.         //M 代表月
  5.         //d 代表日
  6.         //H 代表24进制的小时
  7.         //h 代表12进制的小时
  8.         //m 代表分钟
  9.         //s 代表秒
  10.         //S 代表毫秒
  11.         SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS" );
  12.         Date d= new Date();
  13.         String str = sdf.format(d);
  14.         System.out.println("当前时间通过 yyyy-MM-dd HH:mm:ss SSS 格式化后的输出: "+str);
  16.         //字符串转日期
  17.         SimpleDateFormat sdf2 =new SimpleDateFormat("yyyy/MM/dd HH:mm:ss" );
  19.         String str2 = "2016/1/5 12:12:12";
  20.         //需要进行异常处理
  21.         try {
  22.             Date d2 = sdf2.parse(str2);
  23.             System.out.printf("字符串 %s 通过格式  yyyy/MM/dd HH:mm:ss %n转换为日期对象: %s",str2,d2.toString());
  24.         } catch (ParseException e) {
  25.             // TODO Auto-generated catch block
  26.             e.printStackTrace();
  27.         }
  28.     }

14、日历对象，采用单例模式获取日历对象Calendar.getInstance();

  1. public static void main(String[] args) {
  2.         Calendar c = Calendar.getInstance();
  3.         Date now = c.getTime();
  4.         // 当前日期
  5.         System.out.println("当前日期：\t" + format(c.getTime()));
  7.         // 下个月的今天
  8.         c.setTime(now);
  9.         c.add(Calendar.MONTH, 1);
  10.         System.out.println("下个月的今天:\t" +format(c.getTime()));
  12.         // 去年的今天
  13.         c.setTime(now);
  14.         c.add(Calendar.YEAR, -1);
  15.         System.out.println("去年的今天:\t" +format(c.getTime()));
  17.         // 上个月的第三天
  18.         c.setTime(now);
  19.         c.add(Calendar.MONTH, -1);
  20.         c.set(Calendar.DATE, 3);
  21.         System.out.println("上个月的第三天:\t" +format(c.getTime()));
  23.     }

更多资源或实战项目详细可以了解：http://how2j.cn/k/interface-inheritance/interface-inheritance-practise/679.html?p=29570

发表评论

表情：
评论列表 （有 0 条评论，555人围观）

还没有评论，来说两句吧...

相关阅读

    相关 java基础学习笔记

    java面向对象：封装，继承，多态(i.静态多态(重载) ii.动态多态(方法重写)) 面向过程：站在计算机的角度去抽象问题和解决问题 面向对象：站在现实世界的角度去抽象和

    我不是女神ヾ我不是女神ヾ/ 0 赞/ 289 阅读