java基本类型取值范围 java 基本类

一 包装类 

1.1什么是包装类

Java是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象。但我们在实际应用中经常需要将基本数据转化成对象，以便于操作。

为了解决这个不足，Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。8种基本数据类型，分别对应一个包装类。包装类均位于java.lang包

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

为什么需要包装类（优点）

1. 某些方法的参数必须是对象，为了让基本数据类型的数据能作为参数，提供包装类。
2. 包装类还可以提供更多的功能
3. 其他特别重要的功能：比如可以实现字符串和基本数据类型之间的转换

public class TestWrapper1 {
    int num;
    Integer in ;
    public static void main(String[] args) {
        //1.某些方法参数是对象，为了让基本数据类型能作为参数
        List list = new ArrayList();
        list.add(new Integer(56)); //int 56
        list.add(new Integer(100));
        list.add(new Double(67.5));
        list.add(99);
        System.out.println(list);
        //2.包装类还可以提供更多的功能
        System.out.println(Integer.SIZE); //
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);     
     System.out.println(Integer.toBinaryString(123)); 
        System.out.println(Integer.toOctalString(123));
        System.out.println(Integer.toHexString(123)); 
        //3.特别重要的功能：可以实现字符串和基本数据类型之间的转换
        String str = "123"; //----123
        int num2 = Integer.parseInt(str);
        System.out.println(num2);
        String str2 = "123.45";
        double d = Double.parseDouble(str2);
        System.out.println(d);
    }

注意 注意1：包装类的对象需要占用栈内存和堆内存，而基本数据类型的（局部）变量只占用栈内存；基本数据类型的变量占用空间少，更简单，更灵活，更高效。 注意2：作为成员变量，初始值不同。int  0；Integer null。 注意3：在这八个类中，除了Character和Boolean以外，其他的都是“数字型“，“数字型”都是java.lang.Number的子类。

 

二 String类

String类、StringBuilder类、StringBuffer类是三个字符串相关类。String类是的对象代表不可变的字符序列，StringBuilder类和StringBuffer类代表可变字符序列。

public class TestString1 {
    public static void main(String[] args) {
        //1.创建一个String对象
        String str = "java是最好的语言"; //字符的个数
        //str = null;
        //str = "";
        //String str2 = new String("好好学习，java是最好的语言");

        //2.操作该String对象
        //2.1最简单的方法
        System.out.println(str.length());//10
        System.out.println(str.isEmpty());//length==0
        System.out.println(str.startsWith("bj"));
        System.out.println(str.endsWith("sxt"));
        System.out.println(str.toUpperCase());
        System.out.println(str.toLowerCase());
        //str = str.toLowerCase();
        System.out.println(str);

        //2.2根据索引确定子串
        System.out.println(str.charAt(3));
//从beginIndex,到endIndex-1结束，共计输出字符个
//endIndex-beginIndex
        System.out.println(str.substring(5,7)); 
        System.out.println(str.substring(7));

        //2.3根据子串确定索引
        System.out.println(str.indexOf("习"));
        System.out.println(str.indexOf("好好学"));
//从第一个字符开始查找，返回找到的第一个匹配的子串的索引
        System.out.println(str.indexOf("java")); 
//如果不存在，就返回-1
        System.out.println(str.indexOf("jav")); 
        System.out.println(str.lastIndexOf("java"));
        System.out.println(str.indexOf("java",8));
        //2.4其他
        //str.compareTo()
        byte [] bytes = str.getBytes();//字符串----byte[]
        System.out.println(bytes.length); // 5*3+5*1=20
        System.out.println(Arrays.toString(bytes));
        //String str2 = new String(bytes); //byte[] ---String
        String str2 = new String(bytes,9,6);
        System.out.println(str2);
        System.out.println(str);

        boolean flag = str.contains("beijing");
        System.out.println(flag);
//        str = str.concat("北京");
//        str = str.concat("昌平区");
//        str = str.concat("朝阳区");
        str = str.concat("xx加油").concat("加油")
.concat("xx科技园");
        System.out.println(str);
        str = str.replace("bj","北京北京");
        System.out.println(str);
        String str3 = "  bj  study  ";
        System.out.println(str3.length());
        System.out.println(str3.trim());
    }

 

 

 

 

方法摘要
char	charAt(int index)          返回指定索引处的 char 值。
int	compareTo(String anotherString)          按字典顺序比较两个字符串。
String	concat(String str)          将指定字符串连接到此字符串的结尾。
boolean	contains(CharSequence s)          当且仅当此字符串包含指定的 char 值序列时，返回 true。
boolean	endsWith(String suffix)          测试此字符串是否以指定的后缀结束。
boolean	equals(Object anObject)          将此字符串与指定的对象比较。
boolean	equalsIgnoreCase(String anotherString)          将此 String 与另一个 String 比较，不考虑大小写。
int	hashCode()          返回此字符串的哈希码。
int	indexOf(int ch)          返回指定字符在此字符串中第一次出现处的索引。
int	indexOf(int ch, int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int	indexOf(String str)          返回指定子字符串在此字符串中第一次出现处的索引。
int	indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
boolean	isEmpty()          当且仅当 length() 为 0 时返回 true。
int	lastIndexOf(int ch)          返回指定字符在此字符串中最后一次出现处的索引。
int	lastIndexOf(int ch, int fromIndex)          返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
int	lastIndexOf(String str)          返回指定子字符串在此字符串中最右边出现处的索引。
int	lastIndexOf(String str, int fromIndex)          返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
int	length()          返回此字符串的长度。
String	replace(char oldChar, char newChar)          返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String	replace(CharSequence target, CharSequence replacement)          使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String	replaceAll(String regex, String replacement)          使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String[]	split(String regex)          根据给定正则表达式的匹配拆分此字符串。
boolean	startsWith(String prefix)          测试此字符串是否以指定的前缀开始。
boolean	startsWith(String prefix, int toffset)          测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
String	substring(int beginIndex)          返回一个新的字符串，它是此字符串的一个子字符串。
String	substring(int beginIndex, int endIndex)          返回一个新字符串，它是此字符串的一个子字符串。
String	toLowerCase()          使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
String	toString()          返回此对象本身（它已经是一个字符串！）。
String	toUpperCase()          使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
String	trim()          返回字符串的副本，忽略前导空白和尾部空白。

 

 

String类源码

• String类是一个final类，意味着该类不能再有子类。
• String类底层是一个字符数组value。各种方法的操作其实都是对该数组的操作。

public final class String
     implements java.io.Serializable, Comparable, CharSequence {    
private final char value[];
    public String() {
        this.value = "".value;
    }
    public String(java.lang.String original) {
        this.value = original.value;
        //this.hash = original.hash;
    }
    public boolean isEmpty() {
        return value.length == 0;
    }
    public int length() {
        return value.length;
    }
    public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }
    public java.lang.String toString() {
        return this;
    }
}

• String类的equals()方法其实就是比较底层的字符数组的各个元素是否相同，只要发现一个字符不相同，就返回false。如果所有字符都相同，返回true。但是如果两个变量指向了同一个字符数组，直接返回true。

public final class String
    implements java.io.Serializable, Comparable, CharSequence {
     public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof java.lang.String) {
            java.lang.String anotherString =
 (java.lang.String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
}

• String类的concat()是创建一个新的字符数组，存放原来字符数组和新加入的字符数组内容，然后以该新数组创建一个新的字符串。

public final class String
        implements java.io.Serializable, Comparable<java.lang.String>, CharSequence {
   public java.lang.String concat(java.lang.String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new java.lang.String(buf, true);
    }
}

StringBuffer和StringBuilder非常类似，均代表可变的字符序列。这两个类都是抽象类AbstractStringBuilder的子类，方法几乎一模一样。

两个类的区别主要是：

StringBuffer  JDK1.0提供的类，线程安全，做线程同步检查，效率较低。

StringBuilder  JDK1.5提供的类，线程不安全，不做线程同步检查，因此效率较高。 建议采用该类。

 

 

方法摘要
StringBuilder	append(boolean b)          将 boolean 参数的字符串表示形式追加到序列。
int	capacity()          返回当前容量。
char	charAt(int index)          返回此序列中指定索引处的 char 值。
StringBuilder	delete(int start, int end)          移除此序列的子字符串中的字符。
StringBuilder	deleteCharAt(int index)          移除此序列指定位置上的 char。
void	ensureCapacity(int minimumCapacity)          确保容量至少等于指定的最小值。
int	indexOf(String str)          返回第一次出现的指定子字符串在该字符串中的索引。
int	indexOf(String str, int fromIndex)          从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
StringBuilder	insert(int offset, boolean b)          将 boolean 参数的字符串表示形式插入此序列中。
int	lastIndexOf(String str)          返回最右边出现的指定子字符串在此字符串中的索引。
int	lastIndexOf(String str, int fromIndex)          返回最后一次出现的指定子字符串在此字符串中的索引。
int	length()          返回长度（字符数）。
StringBuilder	replace(int start, int end, String str)          使用给定 String 中的字符替换此序列的子字符串中的字符。
StringBuilder	reverse()          将此字符序列用其反转形式取代。
String	substring(int start)          返回一个新的 String，它包含此字符序列当前所包含字符的子序列。
String	substring(int start, int end)          返回一个新的 String，它包含此序列当前所包含字符的子序列。
String	toString()          返回此序列中数据的字符串表示形式。

三  日期类

在计算机中，我们把1970 年 1 月 1 日 00:00:00定为基准时间，每个度量单位是毫秒(1秒的千分之一)，如图所示。

3.1Date类

在标准Java类库中包含一个Date类。它的对象表示一个特定的瞬间，精确到毫秒。在网上商城下单时，在对报销单进行审核时，都需要获取当前的时间，通过Date类就可以完成。

public class TestDate {
    public static void main(String[] args) {
        //获取当前的时间
        Date now = new Date();
        //输出当前的时间
        System.out.println(now.toString());
        System.out.println(now.toLocaleString());
        System.out.println(now.getYear()); // 1900+119=2019
        System.out.println(now.getMonth());//  0---11
        System.out.println(now.getDate());//日
//星期几 星期日是0，一周是从星期日开始
        System.out.println(now.getDay());
        System.out.println(now.getHours());
        System.out.println(now.getMinutes());
        System.out.println(now.getSeconds());
        //其他的方法
        long l = now.getTime();
        // 1970年1月1日 00:00:00 GMT以来的毫秒数。
        System.out.println(l);
        System.out.println(System.currentTimeMillis());
        System.out.println(System.nanoTime());

        Date date1 = new Date(-(long)(1000*60*60*24)*31);
        System.out.println(date1.toLocaleString());
        //util.Date  yyyyMMdd hh:mm:ss
        // 一共有三个子类 Date  Time Timestamp
        //sql.Date  yyyyMMdd
        //sql.Time  hh:mm:ss
        //sql/Timestamp 时间戳  yyyyMMdd hh:mm:ss
        //java.sql.Date sDate = new java.sql.Date(l);
        java.sql.Date sDate = 
new java.sql.Date(System.currentTimeMillis());
        System.out.println(sDate);
        java.sql.Date sDate2 =  
java.sql.Date.valueOf("2019-8-06");//对格式有要求
        System.out.println(sDate2);
    }
}

Date类中的很多方法都已经过时了。JDK1.1之前的Date包含了：日期操作、字符串转化成时间对象等操作。JDK1.1之后，日期操作一般使用Calendar类，而字符串的转化使用DateFormat类。

 

3.2 DateFormat类

DateFormat是一个抽象类，一般使用它的的子类SimpleDateFormat类来实现。主要作用就是把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。

需求1：网页注册，需要输入日期，在网页上输入的所有内容，xiaoming,23, 1999-12-23,1999/12/23，但是传送到后台接收到都是字符串  "xiaoming", "23", "1999-12-23","1999/12/23"，需要把字符串----->日期

需求2：注册成功后，在网页上显示日期，可以不同格式来显示"1999-12-23", "1999/12/23"，"1999年12月23日"，需要把日期----->字符串。

public class TestDateFormat {
    public static void main(String[] args) {
       // int age = Integer.parseInt("23abc");
       // System.out.println(age);
        //有缺陷：对日期格式有限制，不能表示时分秒
//        String str = "1999-12-23 ";
//        //String ----Date
//        java.sql.Date date = java.sql.Date.valueOf(str);
//        //Date ---String
//        System.out.println(date.toString());

        DateFormat sdf = 
new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String str = "1999-12-23 09:23:45";
        //String ---Date
        Date date =null;
        try {
            date = sdf.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
//        System.out.println(date.toString());
//        System.out.println(date.toLocaleString());
        //Date--String
        DateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
        String str2 = sdf2.format(date);
        System.out.println(str2);
    }
}

关于日期和时间模式

字母	日期或时间元素	表示	示例
G	Era 标志符	Text	AD
y	年	Year	1996; 96
M	年中的月份	Month	July; Jul; 07
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
d	月份中的天数	Number	10
F	月份中的星期	Number	2
E	星期中的天数	Text	Tuesday; Tue
a	Am/pm 标记	Text	PM
H	一天中的小时数（0-23）	Number	0
k	一天中的小时数（1-24）	Number	24
K	am/pm 中的小时数（0-11）	Number	0
h	am/pm 中的小时数（1-12）	Number	12
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
S	毫秒数	Number	978
z	时区	General time zone	Pacific Standard Time; PST; GMT-08:00
Z	时区	RFC 822 time zone	-0800

 

3.3 Calendar类

Calendar 类是一个抽象类，为我们提供了关于日期计算的相关功能，比如：年、月、日、时、分、秒的展示和计算。GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。

public class TestCalendar {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar cal = new GregorianCalendar();
        //输出日期中的各个部分
        System.out.println(cal.get(Calendar.YEAR));
        System.out.println(cal.get(Calendar.MONTH));
        System.out.println(cal.get(Calendar.DATE));
        System.out.println(cal.get(Calendar.HOUR));
        System.out.println(cal.get(Calendar.MINUTE));
        System.out.println(cal.get(Calendar.SECOND));
        System.out.println(cal.get(Calendar.MONTH));
        System.out.println(cal.get(Calendar.DAY_OF_WEEK));
        //修改日期中各个部分
        cal.set(Calendar.YEAR,2000);
        cal.set(Calendar.MONTH,1);
        cal.set(Calendar.DATE,1); //2019-08-01
        int max =cal.getActualMaximum(Calendar.DATE);
        for(int i=1;i<=max;i++){
            System.out.println(cal.get(Calendar.DAY_OF_WEEK));
            cal.add(Calendar.DATE,1);
        }
        System.out.println(cal.get(Calendar.DAY_OF_WEEK));
        System.out.println(cal.getActualMinimum(Calendar.DATE));
        System.out.println(cal.getActualMaximum(Calendar.DATE));
        //输出Calendar对象
        System.out.println(cal);
        //Date--Calendar之间的转换
        //Date ---->Calendar
        Date now = new Date();
        cal.setTime(now);
        //Calendar---->Date
        Date now2 = cal.getTime();
    }
}

3.4 JDK8的新的日期类

针对JDK8以前的时间日期类设计的不足，比如不支持时区，线程不安全等，JDK8引入了java.time包来作为新的日期时间处理类。

 

属性	含义
Instant	代表的是时间，相当于Date
LocalDate	代表日期，比如2020-01-14
LocalTime	代表时刻，比如12:59:59
LocalDateTime	代表具体时间 2020-01-12 12:22:26
ZonedDateTime	代表一个包含时区的完整的日期时间，偏移量是以UTC/  格林威治时间为基准的
Period	代表时间段
ZoneOffset	代表时区偏移量，比如：+8:00
Clock	代表时钟，比如获取目前美国纽约的时间
DateTimeFormatter	日期和字符串格式转换

 

四 其他常用类

Math类

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。如果需要更加强大的数学运算能力，计算高等数学中的相关内容，可以使用apache commons下面的Math类库。

public class TestMath {
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.round(3.14));
        System.out.println(Math.ceil(3.14));
        System.out.println(Math.floor(3.14));

        System.out.println(Math.sqrt(64));//开平方
        System.out.println(Math.pow(2,5));//幂

        System.out.println(Math.abs(-5));
        System.out.println(Math.max(30,40));
        System.out.println(Math.min(30,40));

        System.out.println(Math.random());//[0.0,1.0)
    }
}

Random类

Math类中虽然为我们提供了产生随机数的方法Math.random()，但是通常我们需要的随机数范围并不是[0, 1)之间的double类型的数据，这就需要对其进行一些复杂的运算。如果使用Math.random()计算过于复杂的话，我们可以使用例外一种方式得到随机数，即Random类，这个类是专门用来生成随机数的，并且Math.random()底层调用的就是Random的nextDouble()方法。

public class TestRandom {
    public static void main(String[] args) {
        //Random rand = new Random(10000);
        Random rand = new Random();
        System.out.println(rand.nextInt());
        System.out.println(rand.nextInt(10)); 
        System.out.println(rand.nextDouble());
        System.out.println(rand.nextFloat());
        for (int i = 0; i < 10; i++) {
            System.out.print(rand.nextInt(10)+"  ");
        }
    }
}

构造方法摘要
Random()          创建一个新的随机数生成器。
Random(long seed)          使用单个 long 种子创建一个新的随机数生成器。

枚举

JDK1.5引入枚举类型。枚举类型的定义包括枚举声明和枚举体。枚举体就是放置一些常量。

定义枚举要使用enum关键字。对于性别、季节、星期几等内容，如果定义为字符串类型，是很难限制其取值的。采用枚举可以轻松解决该问题。

//定义和使用性别枚举类
public enum Gender {
    男,女
}
public class Person {
    String name;
    //String sex;//gender
    Gender sex;
    int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Gender getSex() {
        return sex;
    }
    public void setSex(Gender sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public static void main(String[] args) {
        Person person = new Person();
        //person.sex = "adfadfad";
        person.sex = Gender.男;
        System.out.println(person.getSex());
    }
}

//【示例】定义和使用季节枚举类
public enum Season {
    春,夏,秋,冬
}
public class TestSeason {
    public static void main(String[] args) {
        Season season = Season.夏;
        switch(season){
            case 春 :
                System.out.println("春暖花开  踏青  春游  ");
                break;
            case 夏 :
                System.out.println("夏日炎炎  吃雪糕 游泳");
                break;
            case 秋 :
                System.out.println("秋高气爽  收庄稼  赏月");
                break;
            case 冬 :
                System.out.println("冬雪皑皑  泡温泉  打雪仗");
                break;
        }
    }
}

 

所有的枚举类型隐性地继承自 java.lang.Enum。枚举实质上还是类！而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final修饰的。可以直接通过枚举类型名使用它们。

 

注意 强烈建议当你需要定义一组常量时，使用枚举类型； 另外尽量不要使用枚举的高级特性