Java——对数据的处理

素颜马尾好姑娘i 2023-08-17 17:33 83阅读 0赞

### Java中对数据的处理 ###

*  所有的包装类，都有共同的方法：
 *  包装类的使用（以Integer为例）（所有包装类具有相似的成员）
 *  在Java中，有一个专门操作这种随机性数据的类，它就是Random类。
 *  如何对数据进行排列和整理？

--------------------

***本人是个新手，写下博客用于自我复习、自我总结。  
如有错误之处，请各位大佬指出。  
参考教材：零基础学Java***

--------------------

Java中分为基本数据类型和对象数据类型，本部分讲述对象数据类型的处理方法

Java是一种面向对象语言，Java中的类把方法与成员变量组合在一起，构成了独立的处理单元。在Java中不能定义基本类型的对象，为了能将基本类型当为对象来处理，并能调用相关的方法，Java为每个基本类型都提供了包装类，这样便可以把这些基本类型转化为对象来处理。包装类：Boolean,Byte,Short,Integer,Long,Float,Double,Character

# 所有的包装类，都有共同的方法： #

\*带有基本值参数并创建包装类对象的构造函数，  
如Integer obj=new Integer(145);

\*带有字符串参数并创建包装类对象的构造函数  
如new Integer("-45.36");

\*生成字符串表示法的toString()方法，如obj.toString();

\*对同一个类的两个对象进行比较的equals()方法，如obj1.equals(obj2);

\*生成散列表代码的hashCode()方法，如obj.hashCode();

\*将字符串转换为基本值的parseType()方法，如Integer.parseType(args\[0\]);

\*可生成对象基本值的typeValue()方法，如obj.intValue();

# 包装类的使用（以Integer为例）（所有包装类具有相似的成员） #

构造方法：

\*public integer(int value)  
将整型值value包装成持有此值的Integer类对象

\*public integer(string s)  
将由数字字符包装成持有此值的Integer类对象。若s并非由数字构成的话，则会异常抛出。

例：

public class Test{ 
    	public static void main(String args[]){ 
        	int x=12;
        	String str="12345";
        	Integer t1=new Integer(x);
        	Integer t2=new Integer(str);
        	System.out.println(t1.toBinaryString(x));
        	System.out.println(t1.toHexString(x));
        	System.out.println(t2);
     	}
    }

虽然将不同类型的数据作为对象输出，输出结果虽然是数字，但它们是对象数据，而不是基本类型的数据。

常用方法：

public int intValue() 将当前对象转换成相应类型  
public short shortValue()将当前对象转换成相应类型  
public long longValue()将当前对象转换成相应类型  
public float floatValue()将当前对象转换成相应类型  
public double doubleValue()将当前对象转换成相应类型  
public static int parseInt(string s)  
将字符串s转换为十进制整型数，并将其返回  
public static int parseInt(string s,int radix)  
将字符串s转换为radix指定进制的整型数，并将其返回  
public static string toBinaryString(int i)  
将整型数i转换为二进制字符串的形式，并将其返回  
public static string toHexString(int i)  
将整型数i转换为十六进制字符串的形式，并将其返回  
public static string toOctalString(int i)  
将整型数i转换为八进制字符串的形式，并将其返回  
public static string toString(int i)  
将整型数i转换为十进制字符串的形式，并将其返回

例：

public class Test{ 
    	public static boolean isNumberic(String str){ 
    		try{   //捕获异常
    			Integer i=new Integer(str); 
    		}catch(NumberFormatException e){ 
    			return false;
    		}
    		return true;
    	}
    	public static void main(String args[]){ 
        	System.out.println(isNumberic("123"));
        	System.out.println(isNumberic("0x12"));
        	System.out.println(isNumberic("-123.43"));
        	System.out.println(isNumberic("labcd"));
        	System.out.println(isNumberic("322"));
    	}
    }

也就是说构造方法可以作为一个判断的依据。

在面向对象的语法中，处理的对象一般都是对象。但是基本数据类型却不是对象，即用int、double、boolean等定义的变量都不是对象。在以前的版本中，为了解决把基本数据类型转换为对象的问题，出现了打包类型。在最新的版本中，出现了基本数据的自动拆装箱操作。

例：

public class Test{ 
    		public static void main(String args[]){ 
        	//以前实现int类型转换成对象方式
        	Integer data11=new Integer(10); 
        	Integer data12=new Integer(10);
        	Integer data21=Integer.valueOf(10);
        	Integer data22=Integer.valueOf(10);
        	//通过自动装箱方式实现int类型转换成对象方式
        	Integer data31=20;
        	Integer data32=20;
        	//通过自动拆箱方式实现对象转换成int类型方式
        	int sum1=data11+30;
        	int sum2=data31+20;
        	System.out.println("sum1的值为："+sum1);
        	System.out.println("sum2的值为："+sum2);
        	System.out.println("data11与data12是否为同一对象？"+
        	(data11==data12));
        	System.out.println("data11与data12是否为同一对象？"+
        	(data21==data22));
        	System.out.println("data11与data12是否为同一对象？"+
        	(data31==data32));
        	}
     }

可知，如果int类型转换成Integer类对象，可以通过三种方式实现，  
分别为：new Integer() 、Integer.valueOf()、Integer data=20  
显然最后一种方法最简单。

对象data11和data12之所以不是引用同一个对象，是因为这两个对象都是通过关键字new来创建。但是剩余两对对象在数据小于127的情况下，却引用同一个对象，这是因为对象data21和data22是通过Integer.valueOf()方法返回同一个数值的引用，而对象data31和data32是通过自动装箱操作返回同一个数值的引用。

# 在Java中，有一个专门操作这种随机性数据的类，它就是Random类。 #

常用方法：  
public boolean nextBoolean():返回true或者是false  
public double nextDouble():返回0~1之间的double型小数  
public float nextFloat():返回0~1之间的float型小数  
public int nextInt():返回int型整数  
public int nextInt(int n):返回0~n之间的整数  
public long nextLong():返回long型整数

需要import java.util.Random;  
例：

import java.util.Random;
    
    public class Test{ 
    	public static void main(String args[]){ 
        	Random rnd=new Random();
        	//通过随机类对象的方法随机的给数据赋值
        	int a=rnd.nextInt(10);
        	int b=rnd.nextInt(10)+5;
        	int c=3*rnd.nextInt(10);
        	System.out.println(a);
        	System.out.println(b);
        	System.out.println(c);
        }
    }

例：

import java.util.Random;
    
    public class Test{ 
    	public static void main(String args[]){ 
        	try{ 
        		Random rnd=new Random(); 
        		//创建一个字符串类型的数组card
        		String[] card={ "方块1","方块2","方块3","方块4"};
        		//创建关于循环的各种变量
        		String str;
        		int x,y;
        		//通过循环语句，不断从数组中取出两个对象，对其进行比较和排序
        		for(int i=0;i<100;i++)
        		{ 
        			x=rnd.nextInt(3);
        			y=rnd.nextInt(3);
        			str=card[x];
        			card[x]=card[y];
        			card[y]=str;
        		}
        		//输出
        		for(int i=0;i<4;i++)
        		{ 
        			System.out.println(card[i]);
        		}
        	}catch(Exception e){    		
        	}
        }
    }

例：

import java.util.Random;
    
    public class Test{ 
    	public static void main(String args[]){ 
        	try{ 
        		Random rnd=new Random(); 
        		//创建变量
        		String[] hand={ "剪刀","石头","布"};
        		//输出相应信息
        		System.out.println("游戏开始");
        		System.out.print("剪刀（0），石头（1），布（2）中，你要选择哪一个？");
        		//获取输入值
        		int c=System.in.read();
        		System.out.println("<结果>");
        		//通过分支语句来输出不同的结果
        		switch(c){ 
        		case'0':
        			System.out.println("玩家:"+hand[0]);
        			break;
        		case'1':
        			System.out.println("玩家:"+hand[1]);
        			break;
        		case'2':
        			System.out.println("玩家："+hand[2]);
        			break;
        		}
        		int b=rnd.nextInt(3);//获取一个随机数变量b
        		System.out.println("计算机："+hand[b]);
        		if((c-48)==0&&b==2){ 
        			System.out.println("玩家胜利！");
        		}
        		else if((c-48)==2&&b==0){ 
        			System.out.println("计算机胜利！");
        		}
        		else if((c-48)>b){ 
        			System.out.println("玩家胜利!");
        		}
        		else if((c-48)<b){ 
        			System.out.println("计算机胜利！");
        		}
        		else if((c-48)==b){ 
        			System.out.println("平手！");
        		}
        	}catch(Exception e){    		
        	}
        }
    }

# 如何对数据进行排列和整理？ #

在排序方面，Java提供了Arrays类来处理这个问题，Arrays类提供了数组整理、比较和检索功能。Arrays类中所有的方法都是静态方法，所以不需要创建Arrays类对象，其常用方法：（其他基本类型同理）

public static boolean equals(int\[\] a,int\[\] a1)  
比较两个数组，如果两个数组的元素相同，则返回true，否则返回false

public static boolean(object\[\] a,object\[\] b)  
比较两个对象型数组，如果两个数组的元素相同，则返回true,否则返回false

public static void fill(int\[\] a,int val)  
将数组a中的所有元素填充为val

public static void sort(int\[\] a)  
将给定的数组a按升序排列

例：

public class Test{ 
    	public static void main(String args[]){ 
        	int[] a=new int[]{ 2,34,21,11,23,56,65,33,89,90};
        	Arrays.sort(a);
        	for(int i=0;i<a.length;i++){ 
        		System.out.println(a[i]+" ");
        	}
        	System.out.println("56的位置为："+Arrays.binarySearch(a, 56));
        	System.out.println("33的位置为："+Arrays.binarySearch(a, 33));
        }
    }

基本数据之间可以比较大小，而对象分为可比较对象和不可比较对象，这取决于其是否实现了Comparable接口，可比较对象实现了Comparable接口，而不可比较对象则没有实现此接口。要想实现这个接口，就应该实现Comparable接口中的compareTo()方法。

如下所示：

public interface Comparable{ 
            public int compareTo(object o){ };
        }
          
       class student implements Comparable{ 
       			....//相关信息
                   public int compareTo(object o){ 
                       student st=(student) o;
                       return (age-st.age);
                   }
       }