/*
八种数据类型：byte,short,int,long,float,double,char,boolean,
基本数据类型对象包装类：
为了方便操作基本数据类型值，将其封装成对象，在对象中定义了属性和行为丰富该数据的操作。
用于描述对该对象的类就称为基本数据类型对象封装类。
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
基本数据类型 —— ——>字符串的方法：
1，基本数值类型+"";
2，用String类中的静态方法valueOf(基本类型数值);
3，用Integer的静态方法valueOf(基本类型数值)
字符串—— ——>基本数据类型的方法：
1，使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串");
eg：int i=int.parseInt("123");
double d=double.parseDouble("234.56");
byte
short
long
float
boolean
以上都有parseXxx方法，但是Character没有这种方法。
2，如果字符串被Integer进行了对象封装，可以使用非静态方法.intValue();
将一个Integer对象转成基本数据类型。
进制转换：
1，十进制转其他进制：
Integer.toBinaryString(60);
Integer.toOctalString(60);
Integer.toHexString(60);
有一个比较通用的进制转换方法：
Integer.toString(60,2);//注意：这个方法和Object类中的toString()方法是不一样的，
//因为这个方法有参数，即toString(para1,para2);
//第一个参数是需要转换进制的数，第二个参数是指明需要被转成哪一进制。
2，其他进制转换为十进制：
Integer.parseInt("110",2);//解释：第一个参数是数值字符串，第二个参数是指明前面的数值的进制，即110是2进制的。
此方法结果返回的是十进制的整数类型的。
*/
class WrapperDemo
{
public static void main(String[] args)
{
int num=0;
sop("Integer.MAX_VALUE:"+Integer.MAX_VALUE);
sop("Integer.MIN_VALUE:"+Integer.MIN_VALUE);
sop("Integer.SIZE:"+Integer.SIZE);
sop("Byte.SIZE:"+Byte.SIZE);
sop("Byte.MAX_VALUE:"+Byte.MAX_VALUE);
sop("Byte.MIN_VALUE:"+Byte.MIN_VALUE);
sop("Character.SIZE:"+Character.SIZE);
Integer i=new Integer(num);
int j=23456;
String str=String.valueOf(j);
sop("str"+str);
sop("进制转化------十进制转其他进制---------------");
sop(Integer.toBinaryString(60));
sop(Integer.toOctalString(60));
sop(Integer.toHexString(60));
sop(Integer.toString(60,2));
sop("进制转换------其他进制转十进制---------------");
sop(Integer.parseInt("110",2));
sop(Integer.parseInt("60",10));
sop(Integer.parseInt("3c",16));
sop(Integer.parseInt("60",8));
//sop(Integer.parseInt("3c",2));//这个会出错的。因为3c不是二进制的数
Integer a=new Integer(123);//Integer(int value)是将一个整数封装成Integer对象。
Integer b=new Integer("123");//Integer(String s)是将String参数所指示的int值封装成Integer对象。
//Integer c=new Integer("3c");//这是会出错的，因为String所指示的必须是int类型的数值，即“ ”里面必须是数字。
//sop("c"+c);
sop("a.compareTo(b):"+a.compareTo(b)); //0代表对象内容相同。1代表a的ascii码值大于b的ascii码值。-1代表小于。
sop("a"+(a+100));
sop("b"+(b+100));
sop("a==b:"+(a==b));//==比较的是两个对象，对象肯定不是一样的。
sop("equals:"+a.equals(b));//equals覆盖重写了Object中的equals方法。
//Object中的equals方法是比较两个对象；
//Integer中的equals方法是比较两个对象的内容是否相同。
Integer a1=127;//JDK1.5以后，自动装箱，如果装箱的是<<一个字节>>，那么该数据会被共享不会重新开辟空间。正如字符串一样。
Integer a2=127;//但是一定要注意这是<<一个字节>>。一个byte的取值范围是-128~127。所以当a1和a2的值为128时，a1==a2返回的就是false了。
sop(a1==a2);
sop(a1.equals(a2));
Integer in=new Integer("123");
//in=in+123;
//sop("in.............:"+in);
//sop(Integer.parseInt(in));//注意这里是错误的，因为parseInt()里的参数必须是int数字的字符串，而在这里参数是Integer对象。
try
{
int x=Integer.parseInt("123"); //parseInt()方法中参数必须为数字字符串，不能含有其他字符。
//sop(x+1);
}
catch (Exception e)
{
sop(e.toString());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*
对一个字符串中的数值进行从小到大的排序。
“20 78 9 -7 88 36 29”
*/
import java.util.*;
class WrapperTest
{
private static final String SPACE_SEPARATOR=" ";
public static void main(String[] args)
{
String str="20 78 9 -7 88 36 29";
int[] arr=split(str);//分割并转为整型
//Arrays.sort(arr);
arr=search_sort(arr);//排序（升序）
sop(arrayToString(arr));
for(int i=0;i<arr.length;i++)
{
sop(arr[i]);
}
}
/*分割字符串：
1，先生成字符串数组；
2，将字符串类型的数组转化为整型数组，即对每一个元素进行parseInt转换；
3，对整型数组进行排序；
4，将整型数组转化为字符串输出。
*/
public static int[] split(String str) //分割并转化成整型数组
{
String[] arr=str.split(SPACE_SEPARATOR+"+");//注意："+"代表中间可能有多个空格。
int[] arr1=new int[arr.length];
for(int i=0;i<arr.length;i++)
{
arr1[i]=Integer.parseInt(arr[i]);
}
return arr1;
}
public static int[] search_sort(int[] arr) //对整型数组进行排序
{
for(int i=0;i<arr.length-1;i++)
{
for(int j=i+1;j<arr.length;j++)
{
if(arr[i]>arr[j])
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
return arr;
}
public static String arrayToString(int[] arr)
{
StringBuffer sb=new StringBuffer();
for(int i=0;i<arr.length;i++)
{
if(i!=arr.length-1)
sb.append(arr[i]+SPACE_SEPARATOR);
else
sb.append(arr[i]);
}
return sb.toString();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
时间： 2024-10-30 20:33:39