java基本类型存储在哪 java的基本类

常用类

1、包装类

初识包装类

public class WrapperClassTest {
    public static void main(String[] args) {
        Integer i = new Integer(10);
        Integer j = new Integer(50);
    }
}

内存分析

1.2、包装类的用途

总结：

1、可以用这些对象中的属性和行为操作基本数据类型，可以实现基本类型和字符串之间的转换。

2、可以当做集合的类型来使用。

使用：

public class Test {
    /** 测试Integer的用法，其他包装类与Integer类似 */
    void testInteger() {
        // 基本类型转化成Integer对象
        Integer int1 = new Integer(10);
        Integer int2 = Integer.valueOf(20); // 官方推荐这种写法
        // Integer对象转化成int
        int a = int1.intValue();
        // 字符串转化成Integer对象
        Integer int3 = Integer.parseInt("334");
        Integer int4 = new Integer("999");
        // Integer对象转化成字符串
        String str1 = int3.toString();
        // 一些常见int类型相关的常量
        System.out.println("int能表示的最大整数：" + Integer.MAX_VALUE); 
    }
    public static void main(String[] args) {
        Test test  = new Test();
        test.testInteger();
    }
}

 

1.3、自动装箱和拆箱

Integer i = 100; 

int j = new Integer(100);

那什么是自动装箱和自动拆箱呢？

自动装箱：就是自动将基本数据类型装换为包装器类型；

自动拆箱：就是自动将包装器类型转换为基本数据类型；

那么拆箱和装箱的动作什么时候开始执行呢？

   java装箱过程是调用包装类的valueOf方法实现的，而拆箱过程则是调用包装类的xxxValue方法实现的（xxx代表对应的基本类型）

1.4、包装类的缓存问题

  整型（byte、short、int、long）、char类型所对应的包装类，在自动装箱时，对于-128~127之间的值会进行缓存处理，其目的是提高效率。

public class TestBzl {
   public static void main(String[] args) {
	  Integer i1=127;
	  Integer i2=127;
	  System.out.println(i1==i2);
	  Integer I3=134;
	  Integer I4=134;
	  System.out.println(I3==I4);
}
}

2、String 类

   为什么它是不可变的字符序列呢？

    我们发现字符串内容全部存储到value[]数组中，而变量value是final修饰的，也就是常量(即只能被赋值一次)。 这就是“不可变对象”的典型定义方式。

2.2、StringBuffer和StringBuilder

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

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char value[];
//以下代码省略
}

2.2.1、StringBuffer和StringBuilder的区别

1. StringBufferJDK0版本提供的类，线程安全，做线程同步检查， 效率较低。
2. StringBuilder JDK1.5版本提供的类，线程不安全，不做线程同步检查，因此效率较高。（推荐使用）

2.2.2、常用方法列表：

public int indexOf(String str)
public int indexOf(String str,int fromIndex)
public String substring(int start)
public String substring(int start,int end)
public int length() 
char charAt(int index)

2.3、不可变和可变字符序列使用陷阱

       String一经初始化后，就不会再改变其内容了。对String字符串的操作实际上是对其副本(原始拷贝)的操作，原来的字符串一点都没有改变。比如：

2.3.2、String和StringBuilder在频繁字符串修改时效率测试

public abstract class TestString {
	public static void main(String[] args) {
		String str="";
		long num1=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
		long time1=System.currentTimeMillis();//获取系统的当前时间
		for (int i = 0; i < 6000; i++) {
			str+=i;
		}
		long num2=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
		long time2=System.currentTimeMillis();//获取系统的当前时间
		System.out.println("String 占用内存："+(num1-num2));
		System.out.println("String 占用时间："+(time2-time1));
		
		//
		StringBuilder builder=new StringBuilder();
		long num3=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
		long time3=System.currentTimeMillis();//获取系统的当前时间
		for (int i = 0; i < 6000; i++) {
			builder.append(i);
		}
		long num4=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
		long time4=System.currentTimeMillis();//获取系统的当前时间
		System.out.println("StringBuilder 占用内存："+(num3-num4));
		System.out.println("StringBuilder 占用时间："+(time4-time3));
	}
}

 结果：

3、时间类 （datetime）

long now = System.currentTimeMillis();

构造器	说明
Date()	分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date)	分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

返回值	方法（形参）	说明
boolean	after(Date when)	测试此日期是否在指定日期之后。
boolean	before(Date when)	测试此日期是否在指定日期之前。
Object	clone()	返回此对象的副本。
int	compareTo(Date anotherDate)	比较两个日期的顺序。
boolean	equals(Object obj)	比较两个日期的相等性。
long	getTime()	返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
void	setTime(long time)	设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。

 

3.2、DateFormat类和SimpleDateFormat类

  3.2.1、DateFormat类的作用   

将时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。

public class TestTime {
	public static void main(String[] args) {
		Date date=new Date();
		SimpleDateFormat s1=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		// 将时间对象转换成字符串
        String daytime = s1.format(date);
        System.out.println(daytime);
	}
}

结果：

 

 代码中的格式化字符的具体：

时间格式字符的使用：

import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDateFormat2 {
    public static void main(String[] args) {
        SimpleDateFormat s1 = new SimpleDateFormat("D");
        String daytime = s1.format(new Date());
        System.out.println(daytime);
    }
}

 

3.3、Calendar日历类

注意：注意月份的表示，一月是0，二月是1，以此类推，12月是11。

public class TestCalendar {
	public static void main(String[] args) {
		GregorianCalendar calendar=new GregorianCalendar();
		//获取日期
		int year=calendar.get(Calendar.YEAR);//获取年份  或者用1
		int month=calendar.get(Calendar.MONTH)+1;//月份是从0开始的  或者用2
		int day = calendar.get(Calendar.DAY_OF_MONTH); // 获取当前天数 或者用5
        int day2 = calendar.get(Calendar.DATE); // 获取当前天数  或者用5
        int week=calendar.get(Calendar.DAY_OF_WEEK);//获取星期几  或者用7/4
        printCalendar(calendar);
        // 星期几 这里是：1-7.周日是1，周一是2，。。。周六是7
		//设置日期
        GregorianCalendar calendar2=new GregorianCalendar();
        calendar2.set(Calendar.YEAR, 2000);
        calendar2.set(Calendar.MONTH, 10);
        calendar2.set(Calendar.DATE, 3);
        calendar2.set(Calendar.HOUR_OF_DAY, 10);
        calendar2.set(Calendar.MINUTE, 20);
        calendar2.set(Calendar.SECOND, 23);
        printCalendar(calendar2);
        //日期计算
        GregorianCalendar calendar3=new GregorianCalendar();
        calendar3.add(Calendar.MONTH, -7); // 月份减7
        calendar3.add(Calendar.DATE, 7); // 增加7天
        printCalendar(calendar3);
     // 日历对象和时间对象转化
        //Calendar--->date
        Date d=calendar3.getTime();
        //date--->Calendar
        GregorianCalendar calendar4 = new GregorianCalendar();
        calendar4.setTime(new Date());
	}
	public static void printCalendar(Calendar calendar) {
		String[] str= {"日","一","二","三","四","五","六"};
		int year=calendar.get(Calendar.YEAR);
		int month=calendar.get(Calendar.MONTH)+1;
		int day=calendar.get(Calendar.DAY_OF_MONTH);
		int date=calendar.get(Calendar.DAY_OF_WEEK);
		int hour=calendar.get(Calendar.HOUR);
		String week = str[date-1];
		int minute=calendar.get(Calendar.MINUTE);
		int second=calendar.get(Calendar.SECOND);
		System.out.printf("%d年%d月%d日,星期%s %d:%d:%d\n", year, month,
   day,week, hour, minute, second);
	}
}

万年历：

public class TestCalendar2 {
   public static void main(String[] args) {
	   System.out.println("请输入日期 (格式为：2010-3-3)：");
	   Scanner scanner=new Scanner(System.in);
	   String date=scanner.next();
	   // 将输入的字符串转化成日期类
       System.out.println("您刚刚输入的日期是：" + date);
       String[] str = date.split("-");
	   int year=Integer.valueOf(str[0]);
	   int month=Integer.valueOf(str[1])-1;
	   int day=Integer.valueOf(str[2]);
	   Calendar c = new GregorianCalendar(year,month,day);
	   int maxDate = c.getActualMaximum(Calendar.DATE);
	   System.out.println("一\t二\t三\t四\t五\t六\t日\n");
	   for (int i = 1; i <=maxDate; i++) {
		   if(day==i) {
			   System.out.print(i+"㊣\t");
		   }else {
			   System.out.print(i+"\t"); 
		   }
		   if(i%7==0) {
			 System.out.println("\n");
		   }
	   }
   }
}

4、Math 类

1. abs 绝对值

2. acos,asin,atan,cos,sin,tan 三角函数

3. sqrt 平方根

4. pow(double a, double b) a的b次幂

5. max(double a, double b) 取大值

6. min(double a, double b) 取小值

7. ceil(double a) 大于a的最小整数

8. floor(double a) 小于a的最大整数

9. random() 返回 0.0 到 1.0 的随机数

10. long round(double a) double型的数据a转换为long型(四舍五入)

11. toDegrees(double angrad) 弧度->角度

12. toRadians(double angdeg) 角度->弧度

Math类的常用方法：

public class TestMath {
    public static void main(String[] args) {
        //取整相关操作
        System.out.println(Math.ceil(3.2));
        System.out.println(Math.floor(3.2));
        System.out.println(Math.round(3.2));
        System.out.println(Math.round(3.8));
        //绝对值、开方、a的b次幂等操作
        System.out.println(Math.abs(-45));
        System.out.println(Math.sqrt(64));
        System.out.println(Math.pow(5, 2));
        System.out.println(Math.pow(2, 5));
        //Math类中常用的常量
        System.out.println(Math.PI);
        System.out.println(Math.E);
        //随机数
        System.out.println(Math.random());// [0,1)
    }
}

4.2、Random类的常用方法

import java.util.Random;
public class TestRandom {
    public static void main(String[] args) {
        Random rand = new Random();
        //随机生成[0,1)之间的double类型的数据
        System.out.println(rand.nextDouble());
        //随机生成int类型允许范围之内的整型数据
        System.out.println(rand.nextInt());
        //随机生成[0,1)之间的float类型的数据
        System.out.println(rand.nextFloat());
        //随机生成false或者true
        System.out.println(rand.nextBoolean());
        //随机生成[0,10)之间的int类型的数据
        System.out.print(rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据
        System.out.print(20 + rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据（此种方法计算较为复杂）
        System.out.print(20 + (int) (rand.nextDouble() * 10));
    }
}

5、File类的基本用法

     java.io.File类：代表文件和目录。 在开发中，创建文件、读取文件、生成文件、删除文件、修改文件的属性时经常会用到本类。

5.1、创建文件

public abstract class TestFile {
	public static void main(String[] args) throws IOException {
		//创建文件
		System.out.println(System.getProperty("user.dir"));
        File f = new File("a.txt"); //相对路径：默认放到user.dir目录下面
        f.createNewFile();
        //测试File类访问属性的基本用法
	}
}

5.2、通过File对象可以访问文件的属性：

//测试File类访问属性的基本用法
//时间格式化
SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
File f=new File("a.txt");
System.out.println("File是否存在："+f.exists());
System.out.println("File是否是目录："+f.isDirectory());
System.out.println("File是否是文件："+f.isFile());
System.out.println("File最后修改时间："
+ format.format(new Date(f.lastModified())));
System.out.println("File的大小："+f.length()+"KB");
System.out.println("File的文件名："+f.getName());
System.out.println("File的目录："+f.getPath());

5.3、通过File对象创建空文件或目录

File file=new File("text.txt");
f.createNewFile();//创建文件
boolean flag=file.mkdir();//创建目录

6、枚举

  格式：

enum  枚举名 {      枚举体（常量列表）}

6.2、创建枚举

enum Season {     SPRING, SUMMER, AUTUMN, WINDER  }

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

注意：

示例：

public class TestEnum {
	public static void main(String[] args) {	
        System.out.println("以下是所有奶茶的价格：");
        for (Tea t: Tea.values()) {
			System.out.println(t+"："+"\t小杯  "+t.getPrice()+"元"
					+"\t中杯 "+(int)(t.getPrice()*1.5)+"元"
					+"\t大杯 "+(int)(t.getPrice()*2)+"元");
		}
	}
}
enum Tea{
	普通奶茶(6),天空之城(12),双皮奶(8);
	private int price;
	Tea(int p){
		price=p;
	}
	int getPrice(){
		return price;
	}
}

结果图：