Java 基础 - 数据类型总结

数据类型

基本数据类型

从小到大排列

类型	关键字	内存占用（字节）	备注	包装类
布尔型	boolean	1/8	true 或者 false； 默认是 false； 不能用 0 或者 1 代表	Boolean
字节型	byte	1	-128 ~ 127	Byte
短整型	short	1	默认值是 0 -2 ^15 ~ 2 ^15 -1	Short
字符型	char	2	0 ~ 65535 char 只能保存一个字符，保存多个会编译报错 char 类型都是可以运算的，因为表示的是unicode 码	Character
整型	int	4	-2^31 ~ 2^31-1 默认值是 0	Integer
单精度浮点型	float	4	默认值是 0.0f	Float
长整型	long	8	- 2^63 ~ 2^63 -1 默认值是 0L	Long
双精度浮点	double	8	默认值是 0.0d	Double

关于基本数据类型的题目

• int

  给 Integer 赋值 int 时，会调用 Integer.valueOf() ， 
  如果 int 的值在 -128 ~ 127 之间，不会直接 new 一个新的对象，
  而是直接引用常量池中的对象。
  基本数据类型的常量池的范围是 - 128 ~ 127 ，
  在这个范围基本数据类型的包装类可以自动拆箱，比较时直接比较大小。
  超出该范围的两个 Integer 比较 == 返回 false
  
  # int 自动装箱时在-128 ~ 127 之间直接使用,常量池中的对象，否则创建新对象
  
  Integer a = 1, b = 1, c = 129, d = 129;
  a == b // true
  c == d // false  
  
  # 手动创建对象时，不会引用常量池中的对象
  Integer a = new Integer(3); 
  Integer b = 3;
  int c = 3;
  # false 两个引用没有引用同一对象
  System.out.println(a == b); 
  # true a自动拆箱成 int 类型再和c比较（易错）
  System.out.println(a == c); 
  

• 浮点型

  # 浮点默认是 double 类型
  int i = 3.5 // 错误
  double d = 1; // d = 1.0
  
  浮点: 
  浮点型默认是 double 类型
  float f = 3.4; (X)
  因为浮点型默认是 double , double 转为 float 为向下转型，会丢失精度
  正确写法：
  float f = 3.4f
  float f = （float）3.4
  

• byte 型

  byte b = (byte)128; // b = -128
  

• short 型

  short s = 1; ( 正确) 
  # 数字类型默认是 int 类型，int 转 short 应该丢失精度，这里是jvm 做了优化
  short s2 = 1 + s1; (错误) // 1 是int ，int 和 short 做运算，short 会自动转化为 int ，
   1 + s1 结果为int ， int 赋值给short 会丢失精度
  s += 1; (正确) // += 相当于 （short）(1 + s)
  

• char 型

  char a = '2' + 2 ;  // 4   
  

引用数据类型

类、接口、数组

关于值传递和引用传递的理解？

基本数据类型的变量作为方法的参数传递时，形参对应的值改变不会影响实参的值，
基本数据类型是值传递
String 作为参数其实是值传递，不会改变原来的值。
引用数据类型是传递的是地址

public static void main(String[] args) {
        OrderExtendDTO orderExtendDTO = new OrderExtendDTO();
        orderExtendDTO.setDriverId(2l);
        int i = 0;
        setOrder(orderExtendDTO, i);
        log.info("orderExtendDTO：{}", JSON.toJSONString(orderExtendDTO)); // orderExtendDTO{"driverId":2}
        log.info("i = {}", i); // i = 0


    }

    // 引用数据类型作为参数，传递的是对象的地址；基本数据类型传递的是值
    private static void setOrder(OrderExtendDTO orderExtendDTO, int i){
    	orderExtendDTO = new OrderExtendDTO();
        orderExtendDTO.setDriverId(3l);
        i = 1;
    }

数组

数组是存储同一种数据类型的容器

数组中的元素与元素之间的内存地址是连续的

数组一旦初始化，长度固定

数组算法

• 查找数组中最大的元素

  public static void main(String[] args) {
  		int[] arr = {12,14,5,-26,14};
  		int max = getMax(arr);
  		System.out.println("最大值："+ max); 
  	}
  	public static int getMax(int[] arr) {
  		int max=arr[0];
  		int length=arr.length;
  		for(int i = 1;i < length;i++) {
  			if(arr[i] > max) {
  				max = arr[i];
  			}
  		}
  		return max;
  	}
  

• 线性查找 - 遍历

• 二分法查找（折半查找）

  /**
  * 对有序数组检索，第一次比较后，省下 n/2 个元素，第二次剩余 n/4，第 k 次剩余 n/2 ^k , 当 k = log 2 ^ n 时， 只剩下一个元  *  素。也就是说，最坏的情况下，需要做 log 2 ^ (n + 1) 次比较，对于一个有1024个元素的数组，最坏情况只需要比较 11 次。 
  *
  */
  public class BinarySearch {
  	public static int binarySearch(int [] a,int key) {
  		int low=0;
  		int high=a.lenth-1;
  		while(low<=high) {
  			int mid=(low+high)/2;
  			if(key==a[mid]) return mid;
  			if(key<a[mid]) {
  				high=mid-1;	
  			} else {
  				low=mid+1
  			}
  		}		
  	}
  }
  

• 选择排序（直接排序）

  /**
   * 选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。
   */
  public class Demo08 {
  
  	public static void main(String[] args) {
  		int[] arr = {2,5,37,8,96,16,49}; 
  		selectSort(arr);
      }
  	public static void selectSort(int[] arr) {
  		//把最大值放在首位置。
  		for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
  			for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
  				if(arr[i]>arr[j]){
  					//交换位置
  					int temp = arr[i];
  					arr[i] = arr[j];
  					arr[j] = temp;
  				}
  			}
  		}
  		//遍历数组，查看效果
  			System.out.print("目前的元素：");
  			for (int i = 0 ; i<arr.length  ;i++){
  				System.out.print(arr[i]+",");
  			}
  		}
  }
  

• 冒泡排序

  /**
   * 
  冒泡排序：冒泡排序的思想就是使用相邻的两个 元素挨个比较一次，符合条件交换位置。
   */
  public class Demo09 {
  
  	public static void main(String[] args) {
  		int[] arr = {2,5,37,8,96,16,49}; 
  		bubbleSort(arr);
  }
  	public static void bubbleSort(int[] arr) {
  		for(int i = 0;i < arr.length-1; i++) {
  			for(int j = 0;j < arr.length-1-i;j++) {
  				if(arr[j]>arr[j+1]) {
  					int temp= arr[j];
  					arr[j] =arr[j+1];
  					arr[j+1]=temp;
  				}
  			}
  		}
  		//遍历数组，查看效果
  				System.out.print("目前的元素：");
  				for (int i = 0 ; i<arr.length  ;i++){
  					System.out.print(arr[i]+",");
  				}
  	}
  

• 数组反转

  /**
   * 定义 一个函数接收一个char类型的数组对象,然后翻转数组中的元素
   */
  public class Demo11 {
  
  	public static void main(String[] args) {
  		char[] arr = { 'a', 'b', 'c', 'd', 'e' };
  		reverse(arr);
  	}
  
  	public static void reverse(char[] arr) {
  		int length = arr.length;
  		for (int startIndex = 0, endIndex = length - 1; startIndex < endIndex; startIndex++, endIndex--){
  			char temp = arr[startIndex];
  			arr[startIndex] = arr[endIndex];
  			arr[endIndex] = temp;
  		}
  		// 遍历数组，查看效果
  		System.out.print("目前的元素：");
  		for (int i = 0; i < arr.length; i++) {
  			System.out.print(arr[i] + ",");
  		}
  	}
  }
  

• 数组工具类 - sort 、binarySearch

  /**
   * toString();
  排序（sort）
  找元素在数组中的位置(二分查找法)  binarySearch
  数组的工具类（Arrays）：
   */
  public class Demo12 {
  
  	public static void main(String[] args) {
  		int[] arr = {12,34,54,76,34,66,78};
  		Arrays.sort(arr);
  		System.out.println(Arrays.toString(arr));
  		
  		System.out.println(Arrays.binarySearch(arr,123));
  	}
  }
  

• 二维数组

  /**
   * 二维数组： 二维数组就是数组中的数组。
   * 二维数组 的定义格式：
  	
  	数据类型[][] 变量名 = new 数据类型[长度1][长度2];
  	
  	二维数组 的初始化方式：
  	
  	动态初始化:
  		
  		数据类型[][] 变量名 = new 数据类型[长度1][长度2];
  	静态初始化：
  		数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}
   */
  public class Demo13 {
  
  	public static void main(String[] args) {
  		//定义一个二维数组
  		int [][] arr =new int[3][25];
  		//二维数组的错误定义
  		//int [] [] aa =new int[][2];
  		arr[1][20]=5;
  		System.out.println(arr.length);
  		System.out.println(arr[1].length);
  		System.out.println(arr[1][20]);	
          // 静态初始化
          int[][] arr = {{122,111,92},{67,12,323,12,2,4,6,7},{3,335,39,40}};
      }
  
  }