Java基础--基本数据类型与包装类

最新推荐文章于 2020-11-29 04:56:43 发布

swping520

最新推荐文章于 2020-11-29 04:56:43 发布

阅读量157

点赞数

分类专栏： java 文章标签： Java基本数据类型与包装类

本文链接：https://blog.csdn.net/swping520/article/details/55652191

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

首先,基本数据类型就不是对象。数据类型可以分为两大类：
　　1）基本类型
　　2）扩展类型,也就是对象.基本数据类型在栈内存中存在,而对象类型在堆内存中存在.
说起来数据,我们第一想到的就是对比,值的大小,或者是不是同一个数据.那么对于基本类型，“==”和“!=”是在比较值。而对于对象来说，“==”和“!=”是在比较两个引用是否相同。而使用equals()方法有一点需要注意：equals()方法的默认行为是比较引用。如果是你自己写的类，你应该为它重写equals()来比较对象的内容。大多数Java类库中的类都实现了比较对象内容的equals()方法。

基本数据类型引用数据类型
byte Byte 8位带符号整数 -128到127之间的任意整数
short Short 16位无符号整数 -32768~32767之间的任意整数
int Integer 32位带符号整数 -231到231-1之间的任意整数
long Long 64位带符号整数 -263到263-1之间的任意整数
float Float 32位单精度浮点数根据IEEE754-1985标准
double Double 64位双精度浮点数根据IEEE754-1985标准
char Characher 字符型
boolean Boolean 布尔型只有两个值true、false

1、byte：byte型（字节型）数据在内存中占用1个字节，表示的存储数据范围为：-128~127。

2、short：short型（短整型）数据在内存中占用2个字节。

3、int：int型（整型）数据在内存中占用4个字节。

4、long：long型（长整型）数据在内存中占用8个字节。

5、float：float型（单精度浮点型）数据在内存中占用4个字节。（float精度为7-8位）

6、double：double型（双精度浮点型）数据在内存中占用8个字节。

7、char：char型（字符型）数据在内存中占用2个字节。char型数据用来表示通常意义上的字符，每个字符占2个字节，Java字符采用Unicode编码，它的前128字节编码与ASCII兼容字符的存储范围在\u0000~\uFFFF，在定义字符型的数据时候要注意加’ ‘，比如 ‘1’表示字符’1’而不是数值1，

8、boolean：数据值只有true或false，适用于逻辑计算。

boolean型,取值为true和false的变量，这种变量称为boolean型变量。　　实例说明

public class test601 
{
    public static void main(string args[])
    {
         boolean x=true;
         boolean y=false;
         System.out.println("x&&y="+(x&&y));
         System.out.println("x||y="+(x||y));
         System.out.println("x^y="+(x^y));
         System.out.println("!x="+(!x));
    }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
 
 1
2
3
4
5
6
7
8
9
10
11
12

根据逻辑运算符的计算表可以得出x&&y=true&&false=false；x||y=true||false=true；x^y=true^false=true；!x=!true=false。

char型　　char型是用来表示字母的，它仅能表示一个单一的字母。通常char型常量必须使用单引号括起来，以与数字区分开来。下面就是一个char型变量的实例：
char letter=’a’; 　　char型在Java语言中并不是很常用，因为如果要存储字符的话，一般使用扩展的数据类型string.

int型　　在Java语言中，提供了多种整型数据类型：byte、short、int、long。它们都是定义了一个整数，唯一的区别就是它们能够表示数据的范围。　　能够表示数据的范围越大，占用的内存空间也就越大，因此，在程序设计中应该选择最合适的类型来定义整数。　　大家可以根据以下规律，记住它们所占的内存空间：　　
1） int是最基本的，它占用32位（现代计算机不就是32位机嘛！）；　　
2） long，长的，也就是比int还长，它占用64位；　　
3） short，短的，也就是比int还短，它占用16位；

4）byte，字节，8位组成一个字节，当然byte就只占8位了。　　根据它们所占用的内存空间不同，能够表示的数字范围也不同。占用内存空间越大，能够表示的数字范围也就越广。
实例说明

public class test602 
{
 public static void main(String args[])
 {
    int x=20;
    System.out.println(x+5);
    System.out.println(x*7);
 }
}　　
public class test603 
{
 public static void main(String args[])
 {
    byte x=129;
    System.out.println(x+5);
 }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5）float型　　前面我们学习了存储整数的变量数据类型，现在我们还看看存储小数的变量数据类型—浮点数。在Java语言中有两种浮点数类型：float、double。其中float是单精度型，占用32位内存空间.
6）double是双精度型，占用64位内存空间。浮点数：浮点数这个名称是相对于定点数而言的，这个点就是小数点。浮点数就是指小数点可以根据需要改位置。

public class test604 
{
    public static void main(String args[])
    {
     float x1=7;
     float y1=9;
     double x2=7.0;
     double y2=9.0;
     System.out.println(x1/y1);
     System.out.println(x2/y2);
    }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
 
 1
2
3
4
5
6
7
8
9
10
11
12

基本数据类型–>字符串:

基本数据类型+””
用String类的静态方法valueOf()方法
字符串–>基本数据类型:
使用包装类中的静态方法 xxx parseXxx (xxx类型的字符串)
int parseInt(“123123”)
long parseLong(“123123”)
boolean parseBoolean(“true”)
char没有这个方法.

如果字符串被Integer进行对象封装,那么可以使用另一个非静态方法:intValue();
将一个Integer对象转成基本数据类型值.

众所周知整数具备不同的进制体现, toHexString() toOctalString() toBinaryString()
Integer.toString(int num,int radix);
其他进制转换为十进制的方法:
Integer.parseInt(String num,int radix) 把指定进制radix的num转换为十进制数

基本数据类型间的转换

自动类型转换：容量小的数据类型可以自动转换成容量大的数据类型，如byte-short-int-long-float-double。byte、short、int不会互相转换，他们三者在计算时会转换成int类型。
强制类型转换：容量大的数据类型转换成容量小的数据类型时，要加上强制转换符，但这样有可能会造成精度降低或者数据溢出，要小心。

基本数据类型与对象的转换:
基本数据类型包装类
byte（字节） java.lang.Byte
char（字符） java.lang.Character
short（短整型） java.lang.Short
int（整型） java.lang.Integer
long（长整型） java.lang.Long
float（浮点型） java.lang.Float
double（双精度） java.lang.Double
boolean（布尔型） java.lang.Boolean
比如

new Character('c'); 
new Integer(3); 
new Byte(12);   
new Short(122);
 
 1
2
3
4
 
 1
2
3
4

等等.

Java1.5以后出现了新特性叫做自动装拆箱.在Java SE 5.0之前，要进行操作后才能将int包装为一个Integer类。JDK 5.0为基本数据类型提供了自动装箱(boxing)和拆箱(unboxing)的功能。

装箱：将基本数据类型包装秤对应的包装类对象。

拆箱：将包装类对象转换成对应的基本数据类型。

Java编译器在编译时期会根据源代码的语法来决定是否进行装箱和拆箱。在运算时，也可以进行自动装箱和拆箱。
比如

int a = 3;
Integer i = new Integer(3);
Integer i2 = 3;//相对于上面的代码.这句代码简化了书写,这就是Java1.5自动装箱的好处.
i = i + a;//这里是怎么做到的呢?就是先吧Integer对象i自动拆箱,然后再与a运算,后再自动装箱.相当于以下代码:
i = new Integer(i.intValue()+a);

 
 1
2
3
4
5
6
 
 1
2
3
4
5
6

那么大家会问:String类跑哪里去了呢?因为String类压根就没有对应的基本数据类型,因此前面一直没有提到过.

想要新建一个String类的对象,也有两种方法,

String s1 = new String("this is String");
String s2 = "this is String";
 
 1
2
 
 1
2

效果相同.

class StringDemo{
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");

        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
    }
}
 
 1
2
3
4
5
6
7
8
9
 
 1
2
3
4
5
6
7
8
9

运行结果:
false //对比的是两个对象的地址
true//调用String类的equals(),返回结果是字符串内容比较结果.
s1代表一个对象,s2有两个对象.new一个对象,abc又是一个对象.两个abc是同一个对象.

        String s1 = "abc";
        String s3 ="abc";
        System.out.println(s1==s3);
 
 1
2
3
 
 1
2
3

运行结果:true.s1,s3指向同一个字符串,因此他俩地址相同,s2跟s1s3不同.”adc”存在于常量池里面,因此地址相同.

String类适用于描述字符串事物,那么它就提供了多个方法对字符串进行操作.常见的方法有哪些?

/*
*String 类
适用于描述字符串事物
* 那么它就提供了多个方法对字符串进行操作
*
* 常见操作:
* “abcd”
*
* 1.获取
* 字符串中包含的字符数,也就是字符串的长度
* int length();返回字符串的长度.数组也有长度,因为长度是数组的属性因此不是方法而是.length
* 根据位置获取位置上的某个字符
* char charAt(int index)
* 根据字符获取该字符在字符串中第一次出现的位置
* int indexOf(int ch) int indexOf(int ch,int fromIndex)从指定位置开始获取ch位置
* int indexOf(String str) int indexOf(String str,int fromIndex)从指定位置开始获取str位置
* int lastIndexOf(char ch)
*
* 2.判断
* 字符串中是否包含某一个子串
* boolean contains(String str) //str.indexOf(str) ==-1 ??
* 字符串中是否有内容
* isEmpty() 原理就是判断length是否为0 “” 跟 null 不一样
* 字符串是否以指定的内容开头或结尾
* boolean startsWith(String str)
* boolean endsWith(String str)
* boolean equals(str)
* boolean equalsIgnoreCase() //忽略了大小写
* 字符串是否以指定内容开头
* 3.转换
* 将字符数组转成字符串
* String(char[] ch)
* String(char[] ch,int offset//起始位置,int count)
* 静态方法
* static String copyValueOf(char[])
* static String copyValueOf(char[],int offset,int count)
* 将基本数据类型转换为字符串
* static String valueOf(char[])
*
* 将字符串转成字符数组
* char[] toCharArray();
* bytes[] getBytes();
* 将字节数组转成字符串
* 将字符串转成字节数组
*
* 4.替换
* replace(char oldchar,char newchar)
* replace(String oldstr,String newstr)
*
* 5.切割
* String[] split (str)
*
* 6.子串.获取字符串中的一部分
* String substring(begin)
* String substring(begin,end)
*
* 7.转换,去除空格,比较
* 7.1将字符串大小写转换
* String toUpperCase()
* String toLowerCase()
*
* 7.2将字符串两端的多个空格去除
* String trim();
* 7.3对两个字符串进行自然顺序的比较
* int compareTo();
*/

那么我们谈到String,就自然想到与之相似的两个容器,StringBuffer,StringBuilder:

1.StringBuffer
是一个容器,长度可变
可以直接操作多个数据类型
最终会通过toString()变成字符串

添加
StringBuffer append(data);
StringBuffer insert(index,data);

删除:
StringBuffer delete(int start,int end);
StringBuffer delete(0,sb.length());
StringBuffer deleteCharAt(int index);
StringBuffer clear();

获取:
char charAt(int index);
int indexOf(String str);
int lastIndexOf(String str);
int length();
String substring(int start, int end) ;

修改:
StringBuffer replace(int start,int end,String str);
void setCharAt(int index,char ch);
StringBuffer reverse();

6.
void getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin)
将缓冲区中的指定数据存储到数组中

2.StringBuilder

jdk1.5版本以后出现.StringBuffer是线程同步的,StringBuilder非同步.

一个容器我们在往里面存的时候另一个线程在修改或者删除,会导致数据错乱.
那么为什么会选择StringBuilder呢?因为StringBuffer还要判断锁.单线程使用
StringBuilder,多线程建议使用StringBuffer.或者也可以自己定义同步代码.
StringBuilder StringBuffer 最终必须转成字符串才可以用.”zhangsan”,true,64sad
升级的三个因素:
提高效率
简化书写
提高安全性.