j*a判断类型(j*a的基本类型)

J*a中怎么知道一个变量的类型

复制下面代码：

class Test{

public static void main(String[] args){

int i=1;//int类型变量

System.out.println(getType(i));//打印变量类型为int

}

public static String getType(Object o){//获取变量类型方法

return o.getClass().toString();//使用int类型的getClass()方法

}

}

扩展资料：

j*a8种基本数据类型(4种整型+2种浮点型+1种字符型+1种逻辑型)

4种整型：

byte-1字节：-128~127；

short-2字节：-32768~32767；

int-4字节：-2^31~2^31-1；

long-8字节：-2^63~2^63-11234。

2种浮点型

float-4字节-32位IEEE 754单精度(有效位数6~7位)；

double-8字节-64位IEEE 754双精度(有效位数15位)。

1种字符型

char-2字节-整个Unicode字符集。

1种逻辑型

boolean-1字节-true或者false。

在j*a字符串中如何判断字符的类型

public static void main(String[] args){

String str=”ABC_001″;

if(str.indexOf(“ABC”)!=-1){

System.out.println(“包含”);

}else{ System.out.println(“不包含”);

}

}

js判断字符串是否包含某字符串,String对象中查找子字符,indexOf

var Cts

=”bblText”;

if(Cts.indexOf(“Text”)

> 0)

{

alert('Cts中包含Text字符串');

}

indexOf用法:

返回 String对象内第一次出现子字符串的字符位置。

strObj.indexOf(subString[, startIndex])

参数

strObj

必选项。String对象或文字。

subString

必选项。要在 String对象中查找的子字符串。

starIndex

可选项。该整数值指出在 String对象内开始查找的索引。如果省略，则从字符串的开始处查找。

说明

indexOf方法返回一个整数值，指出 String对象内子字符串的开始位置。如果没有找到子字符串，则返回-1。

如果 startindex是负数，则 startindex被当作零。如果它比最大的字符位置索引还大，则它被当作最大的可能索引。

从左向右执行查找。否则，该方法与 lastIndexOf相同。

示例

下面的示例说明了 indexOf方法的用法。

function IndexDemo(str2){

var str1=”BABEBIBOBUBABEBIBOBU”

var s= str1.indexOf(str2);

return(s);

}

对于J*aScript的indexOf忽略大小写

j*ascript中indexOf函数方法返回一个整数值，指出 String对象内子字符串的开始位置。如果没有找到子字符串，则返回-1。如果 startindex是负数，则 startindex被当作零。如果它比最大的字符位置索引还大，则它被当作最大的可能索引。

indexOf函数是从左向右执行查找。否则，该方法与 lastIndexOf相同。

下面的示例说明了indexOf函数方法的用法。

function IndexDemo(str2){

var str1

=”BABEBIBOBUBABEBIBOBU”

var s

= str1.indexOf(str2);

return(s);

}

j*a截取相关

1、length()字符串的长度

例：char chars[]={'a','b'.'c'};

String s=new String(chars);

int len=s.length();

2、charAt()截取一个字符

例：char ch;

ch=”abc”.charAt(1);返回'b'

3、getChars()截取多个字符

void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)

sourceStart指定了子串开始字符的下标，sourceEnd指定了子串结束后的下一个字符的下标。因此，子串包含从sourceStart到sourceEnd-1的字符。接收字符的数组由target指定，target中开始复制子串的下标值是targetStart。

例：String s=”this is a demo of the getChars method.”;

char buf[]=new char[20];

s.getChars(10,14,buf,0);

4、getBytes()

替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()。

5、toCharArray()

6、equals()和equalsIgnoreCase()比较两个字符串

7、regionMatches()用于比较一个字符串中特定区域与另一特定区域，它有一个重载的形式允许在比较中忽略大小写。

boolean regionMatches(int startIndex,String str2,int str2StartIndex,int numChars)

boolean regionMatches(boolean ignoreCase,int startIndex,String str2,int str2StartIndex,int numChars)

8、startsWith()和endsWith()

startsWith()方法决定是否以特定字符串开始，endWith()方法决定是否以特定字符串结束

9、equals()和==

equals()方法比较字符串对象中的字符，==运算符比较两个对象是否引用同一实例。

例：String s1=”Hello”;

String s2=new String(s1);

s1.eauals(s2);//true

s1==s2;//false

10、compareTo()和compareToIgnoreCase()比较字符串

11、indexOf()和lastIndexOf()

indexOf()查找字符或者子串第一次出现的地方。

lastIndexOf()查找字符或者子串是后一次出现的地方。

12、substring()

它有两种形式，第一种是：String substring(int startIndex)

第二种是：String substring(int startIndex,int endIndex)

13、concat()()连接两个字符串

14、replace()替换

它有两种形式，第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换，形式如下：

String replace(char original,char replacement)

例如：String s=”Hello”.replace('l','w');

第二种形式是用一个字符序列替换另一个字符序列，形式如下：

String replace(CharSequence original,CharSequence replacement)

15、trim()去掉起始和结尾的空格

16、valueOf()转换为字符串

17、toLowerCase()转换为小写

18、toUpperCase()转换为大写

19、StringBuffer构造函数

StringBuffer定义了三个构造函数：

StringBuffer()

StringBuffer(int size)

StringBuffer(String str)

StringBuffer(CharSequence chars)

(1)、length()和capacity()

一个StringBuffer当前长度可通过length()方法得到,而整个可分配空间通过capacity()方法得到。

(2)、ensureCapacity()设置缓冲区的大小

void ensureCapacity(int capacity)

(3)、setLength()设置缓冲区的长度

void setLength(int len)

(4)、charAt()和setCharAt()

char charAt(int where)

void setCharAt(int where,char ch)

(5)、getChars()

void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)

(6)、append()可把任何类型数据的字符串表示连接到调用的StringBuffer对象的末尾。

例：int a=42;

StringBuffer sb=new StringBuffer(40);

String s=sb.append(“a=”).append(a).append(“!”).toString();

(7)、insert()*字符串

StringBuffer insert(int index,String str)

StringBuffer insert(int index,char ch)

StringBuffer insert(int index,Object obj)

index指定将字符串*到StringBuffer对象中的位置的下标。

(8)、reverse()颠倒StringBuffer对象中的字符

StringBuffer reverse()

(9)、delete()和deleteCharAt()删除字符

StringBuffer delete(int startIndex,int endIndex)

StringBuffer deleteCharAt(int loc)

(10)、replace()替换

StringBuffer replace(int startIndex,int endIndex,String str)

(11)、substring()截取子串

String substring(int startIndex)

String substring(int startIndex,int endIndex)

j*a如何判断属性类型

你是想通过传入一个类模板然后判断出某个属性的类型？

利用反射可以做到

Field filed= className.getDeclaredField(parameter);

className为对应类模版，parameter为你的属性名称

filed.getType().toString();然后利用这个方法可以查询到对应属性类型

基本类型直接返回比如 int直接返回int，如果是包装或者引用则直接

返回对应包类名比如 class j*a.lang.Short

如果你要获取所有的还是利用class对象

Field[] fields=className.getDeclaredFields();

循环遍历就可以了

J*a中怎样判断一个变量是否属于哪种类型

变量类型识别有3种方法：

1、通过反射拿到变量的类型；

2、instanceof关键字判断；

3、通过j*a的多态(方法重载)来DIY类型识别。

举例如下：

packagecom.cxyapi.oo;

/**类型识别工具测试类

*@authorcxy@*cxyapi*

*/

publicclassTypeToolsTest

{

publicstaticvoidmain(String[]args)

{

inti=0;

TypeObjectto=newTypeObject();

//1.反射

System.out.println(“to的类型:”+to.getClass().getSimpleName());

System.out.println(int.class.getSimpleName());

System.out.println(Integer.class.getSimpleName());

//但是对于一个不确定类型的基本数据类型变量我们没法用反射来获取其类型。

System.out.println(“———————-“);

//2.instanceof

if(toinstanceofTypeObject){System.out.println(“to是TypeObject类型的”);}

//但是这种办法貌似也没法确定基本数据类型

System.out.println(“———————-“);

//以上两种方式对于对象，引用类型的都很好用，但是对基本数据类型就不那么好用了。

//3.通过多态(方法的重载)

System.out.println(“i是：”+TypeTools.getType(i));

System.out.println(“to是：”+TypeTools.getType(to));

System.out.println(“\”cxyapi\”是：”+TypeTools.getType(“*cxyapi*”));

//可以看出来最后一种方式使用多态的方式达到了检测类型(基本类型和引用类型)的目的

//除了弥补其他两种方式不能检测基本数据类型的不足在外，还能自己DIY类型信息

}

}

//定义一个类，为了演示引用类型的类型检测

classTypeObject{}

自定义的类型识别工具：

packagecom.cxyapi.oo;

importj*a.util.HashMap;

importj*a.util.Map;

/**类型识别工具

*@authorcxy@*cxyapi*

*/

publicclassTypeTools

{

//获得类型

publicstaticMap<String,String>getType(Objecto)

{

Map<String,String>typeInfo=newHashMap<String,String>();

typeInfo.put(“类型”,o.getClass().getSimpleName());

typeInfo.put(“描述”,”引用类型”);

returntypeInfo;

}

publicstaticMap<String,String>getType(inti)

{

Map<String,String>typeInfo=newHashMap<String,String>();

typeInfo.put(“类型”,”int”);

typeInfo.put(“描述”,”整形”);

returntypeInfo;

}

publicstaticMap<String,String>getType(longl)

{

Map<String,String>typeInfo=newHashMap<String,String>();

typeInfo.put(“类型”,”long”);

typeInfo.put(“描述”,”长整型”);

returntypeInfo;

}

publicstaticMap<String,String>getType(booleanb)

{

Map<String,String>typeInfo=newHashMap<String,String>();

typeInfo.put(“类型”,”boolean”);

typeInfo.put(“描述”,”布尔类型”);

returntypeInfo;

}

publicstaticMap<String,String>getType(charb)

{

Map<String,String>typeInfo=newHashMap<String,String>();

typeInfo.put(“类型”,”char”);

typeInfo.put(“描述”,”字符”);

returntypeInfo;

}

publicstaticMap<String,String>getType(floatf)

{

Map<String,String>typeInfo=newHashMap<String,String>();

typeInfo.put(“类型”,”float”);

typeInfo.put(“描述”,”单精度浮点型”);

returntypeInfo;

}

publicstaticMap<String,String>getType(doubled)

{

Map<String,String>typeInfo=newHashMap<String,String>();

typeInfo.put(“类型”,”double”);

typeInfo.put(“描述”,”双精度浮点型”);

returntypeInfo;

}

publicstaticMap<String,String>getType(Strings)

{

Map<String,String>typeInfo=newHashMap<String,String>();

typeInfo.put(“类型”,”String”);

typeInfo.put(“描述”,”字符串类型”);

returntypeInfo;

}

}