重新整理java的学习的东西，感觉自己学东西太不系统了QAQ
先列目录吧，然后再慢慢加内容

目录

---

• 基础数据类型
  • 类型范围说明
  • 基础类型包装
  • 类型转化
• 字符串
  • String类基本操作
  • StringBuilder
  • String与其他类型的转化
• 枚举类
• 时间类
  • Date
  • Calendar
• Input & Output
  • 标准输入输出
  • 文件输入输出
• 大数运算
• 数组
  • 泛型数组

 

基础数据类型

 类型范围说明

  Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。可以参考这个文章：Java 基本数据类型，这边列表说一下

类 型	存储	范围
byte	1 B	[-128 , 127] / [-27 , 27 - 1]
short	2 B	[-32768 , 32767] / [-215 , 215 - 1]
int	4 B	[ -2 147 483 648 , 2 147 483 647] / [-231 , 231 - 1]
long	8 B	[ -9 223 372 036 854 775 808 , -9 223 372 036 854 775 807] / [-263 , 263 - 1]
float	4 B	[ -3.402 823 47E+38F , +3.402 823 47E+38F]（有效数位6~7位）
double	8 B	[ -1.797 693 134 862 315 70E+308 , +1.797 693 134 862 315 70E+308]（有效数位15位）
boolean	\	true / false 两个取值
char	2 B	单一的16位Unicode字符，最小值 \u0000（即为0），最大值是 \uffff（即为65,535）；

注：

• long a=111111111111111111111111(错误，整数型变量默认是int型)
  long a=111111111111111111111111L(正确，强制转换)

• 浮点数不能用来表示精确的值，如货币；
  float f=6.26 (错误 浮点数默认类型是double类型)
  float f=6.26F (转换正确，强制)
  double d=4.55 (正确)

• 强烈建议不要在程序中使用 char 类型 , 除非确实需要处理 UTF 16 代码单元 。 最好将字符串作为抽象数据类型处理

   基础类型包装

  包装类均位于java.lang包，使用时不需要导入，系统自动导入。Java中的8个包装类分别是：Byte，Short，Integer，Long，Float，Double，Character，Boolean它们的使用方式都是一样的，可以实现原生数据类型与包装类型的双向转换。
包装类和基本数据类型的对象关系：

基本类型	包装器类型
boolean	Boolean
char	Character
int	Integer
byte	Byte
short	Short
long	Long
float	Float
double	Double

  对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。

public class PrimitiveTypeTest {  
    public static void main(String[] args) {  
        // byte  
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  
        System.out.println();  
  
        // short  
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  
        System.out.println();  
  
        // int  
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  
  
        // long  
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  
  
        // float  
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  
  
        // double  
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  
  
        // char  
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
        System.out.println("最小值：Character.MIN_VALUE="  
                + (int) Character.MIN_VALUE);  
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
        System.out.println("最大值：Character.MAX_VALUE="  
                + (int) Character.MAX_VALUE);  
    }  
}

结果可以自己跑，或者看实例结果

 类型转化

int n = 10;
Integer in = new Integer(100);
//将int类型转换为Integer类型
Integer in1 = new Integer(n);
//将Integer类型的对象转换为int类型
int m = in.intValue();
//自动装箱
//基本类型就自动地封装到与它相似类型的包装中
Integer i = 100；
//本质上是，编译器编译时自动添加
Integer i = new Integer(100);
//自动拆箱
//包装类对象自动转换成基本数据类型。
int a = new Integer(100);
//本质是上，编译器编译时自动添加
int a = new Integer(100).intValue();
//将字符串”120”按照十进制转换为int，则结果为120
int n = Integer.parseInt(“120”,10);
//将字符串”12”按照十六进制转换为int，则结果为18
int n = Integer.parseInt(“12”,16);
//将字符串”ff”按照十六进制转换为int，则结果为255
int n = Integer.parseInt(“ff”,16);

字符串

 String类基础操作

  有很多，可以看官方API，下面列举一些常用的

//String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。
String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

//空串 "" 是长度为 0 的字符串
if ( str.length() = 0)  /*or*/  if ( str.equals ("") ) /*or*/ str.isEmpty();
//null , 要使用以下条件 
if ( str == null )
//检查一个字符串既不是 null 也不为空串, 这种情况下就需要使用以下条件 
if (str != null && str.length() != 0 )

//子串
String greeting = "Hello";
String s = greeting . substring(0,3) ; //s="Hel"，从0开始，3个字符长

//拼接
String expletive = "Expletive" ; String PC13 = " deleted " ;
String message = expletive + PC13; // message = "Expletive deleted"
String all = String join ( " / " , " S " , " M " , " L " , " XL " ) ; 
// all is the string " S / H / L / XL "
//string1.concat(string2); 返回 string2 连接 string1 的新字符串
String s = "菜鸟教程：";
s = s.concat("www.runoob.com");

//比较，不能使用“==”
"Hello".equals ( greeting )
//不区分大小写
"Hello".equalsIgnoreCase ( " hello")

//获取长度
String greeting = "Hello" ;
int n = greeting.length(); // is 5 .
//要想得到实际的长度, 即码点数量 , 可以调用
int cpCount = greeting codePointCount ( 0 , greeting length() ) ;

//访问字符串某位置字符
char last = greeting charAt (4) ; // last is ’ o ’，计数从0开始

//查找
int locate1 = greeting.indexOf("l"); //2
int locate2 = greeting.indexOf("l",3) //3
int locate3 = greeting.lastIndexOf("lo",1) // not found，因为从位置1反向查找
//返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

 StringBuilder

  当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
  StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
  由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
菜鸟教程的一个例子：

public class Test{
  public static void main(String args[]){
    StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");
    sBuffer.append("www");
    sBuffer.append(".runoob");
    sBuffer.append(".com");
    System.out.println(sBuffer);  
  }
}
//以上实例编译运行结果如下：
菜鸟教程官网：www.runoob.com

 String与其他类型的转化

转自这里

public class Exchange {
    public static void main(String [] args)
    {
        //  1   String <<<----->> int             
        String str1="12";
        int i=Integer.parseInt(str1);         ///  String--->int ; String转其他(float double)类似
        int j=Integer.valueOf(str1).intValue();     ///  String--->int ;  
        
        str1=i+"";                           ///   int ----->String   会产生两个String对象
        str1=String.valueOf(i);             ///   int ----->Strng    只有一个String对象
        str1= Integer.toString(i);          ///  int ----->String    
 
 
        //   2   Stirng  <<<------>>>  char[]     
        String str2 = "ABCD";
        char[] bm = str2.toCharArray();         ///   String----->char[]
        str2 = String.valueOf(bm);           ///    char[]----->String
 
        //   3  Stirng   <<<------->>>  char
        String str3="0123";
        char ch0,ch1;
        ch0=str3.charAt(0);               /// String -->>>char    参数给的是 下标。
        ch1=str3.charAt(1);
 
        char ch2='A';
        str3=ch2+"";                       /// 可以加个空的字符串，将char 转化为 String型
 
        
        //   4  int  <<<------->>>  char[]     
        //   int-->char[]       1.首先要将int 转化为String <采用上面的方法>
        //                      2.然后将String 类型转化为char[]
        //   char[]-->int    与上面步骤相反，先将char[] 转化为 String ，再将String转化为int。
 
 
        //    5  int     <<<------>>> char   比如 '9'   <-->   9
        int k=1;
        char chk=k+48;                        // int -->char  char 型的数字的 ASCII码比这真正的数字（0-9）大48
 
        k=Character.getNumericValue(chk);     // char-->int  静态函数。
        k=chk-48;                             // char -->int   
 
        //  6  char []   <<<---->>>  char     
          char [] ch6={'A','B'};
          char   ch;
          ch=ch6[1];                          //  char [] --->ch  直接赋值
 
          char [] ch7={ch};                //   ch-----> char[]
    }
}

枚举类

参考自Java 枚举(enum) 详解7种常见的用法，只摘录了两种常见用法，除非我自己遇到，不然不会添加我觉得很稀奇的用法。

//定义
public enum Color {  
  RED, GREEN, BLANK, YELLOW  
}
//如果打算自定义自己的方法，
//那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。 
public enum Color {  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
    // 普通方法  
    public static String getName(int index) {  
        for (Color c : Color.values()) {  
            if (c.getIndex() == index) {  
                return c.name;  
            }  
        }  
        return null;  
    }  
    // get set 方法  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public int getIndex() {  
        return index;  
    }  
    public void setIndex(int index) {  
        this.index = index;  
    }  
}  

时间类

 Date

 Calendar

Input & Output

 标准输入输出

Scanner xx = new Scanner( System.in );
System.out.print("enter a number: "); //println换行；print不换行
int number = xx.nextInt();//数据类型为int
/*
nextByte(); 读取一个byte类型的整数。
nextShort(); 读取一个short类型的整数。
nextInt(); 读取一个int类型的整数。
nextLong(); 读取一个long类型的整数。
nextFloat(); 读取一个float类型的整数。
nextDouble(); 读取一个double类型的整数。
next(); 读取一个字符串，该字符在一个空白符之前结束。
nextLine(); 读取一行文本（即以按下enter键为结束标志）。
可用hasNextXXX()来判断是否有下个输入
*/

System.out.printf ("Hello, %s. Next year , you ' ll be %d " , name , age) ;

 文件输入输出

  见参考链接，有时间再转载和添加样例代码
  https://blog.csdn.net/xuehyunyu/article/details/77873420
  https://www.cnblogs.com/longronglang/p/7458027.html

大数运算

 数组

 泛型数组