Operators

2019独角兽企业重金招聘Python工程师标准>>>

Import static用法

    import static 是java SE5中新引入的特性，使得在一个程序中可以引入某个类的static的变量或方法。如下代码所示：

import static java.lang.Integer.parseInt;
public class TestStaticImport {
	public static void main(String args[]){
		System.out.println(parseInt("2"));
	}
}

Import static之后再使用某个类的静态对象或静态方法时就可以直接使用而不用加上类名。

Java Aliasing

Java Aliasing主要表现在两个方面，一个是引用赋值，一个是引用参数传递。

引用赋值的例子：

public class Test7 {
	public static void main(String args[]){
		Student s1 = new Student();
		Student s2 = new Student();
		s1.setAge(11);
		s2.setAge(12);
		System.out.println(s1.getAge());//11
		System.out.println(s2.getAge());//12
		s1=s2;
		System.out.println(s1.getAge());//12
		s1.setAge(13);
		System.out.println(s1.getAge());//13
		System.out.println(s2.getAge());//13
	}
}

class Student{
	private int age;
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
}

引用参数传递的例子：

public class Test8 {
	public static void main(String args[]){
		People p = new People();
		p.setAge(99);
		System.out.println(p.getAge());//99
		new Test8().setPeopleAge(p,100);
		System.out.println(p.getAge());//100
		
	}
	public void setPeopleAge(People p,int age){
		p.setAge(age);
	}
}

class People{
	public int age;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
}

引用赋值使得两个引用指向同一个对象；参数传递时会拷贝一个参数的副本进行操作，如果传递的是对象引用，那么会拷贝一个对象引用的副本，而真正改变的还是原来的对象。

Java获取随机数

Java获取随机数的过程：

Random rand = new Random();
System.out.println(rand.nextInt(100));//随机产生0到99的整数

如果Random构造函数不传参数，则用当前的时间作为随机数产生用的种子。

Randon构造函数也可以接收一个long类型的种子，如果种子确定了，那么产生的随机数也就是确定的了，所以如果给定一个种子，重复运行程序将产生相同的结果。

nextInt()无参数的话随机产生一个可正可负的整数，nextInt(Max)随机产生[0,Max)中的一个整数，nextLong()随机产生一个long(可正可负)，nextDouble()随机产生一个[0.0,1.0)中的一个double，nextFloat()随机产生[0.0,1.0)中的一个float。

Java操作符对byte,short,char的提升

Java单目加减符可以将byte,short,char转成int。

byte a = 1;
   byte b = a;
   byte c = +a;//错误，单目+将“+a”提升成int，int不能直接赋给byte。
   byte d = -a;//错误，单目-将“-a”提升成int，int不能直接赋给byte。

另外java中四则运算和位操作符也会先将byte,short,char提升成int再计算。

byte a = 1;
byte b = a;
byte c= a>>1;//错误，位操作符将a提升成int，再做移位操作，产生的结果是int不能直接赋给byte。
byte d = a*b;//错误，四则运算将a,b提升成int再计算，产生的结果是int不能直接赋给byte。

对于“+=”，“-=”，“*=”，“/=”这些复合赋值符，首先转成int，计算完之后再转回原类型，这些都是语言自动实现的，不需要强制cast。

前加加与后加加

前加加先加1再赋值，后加加先赋值后加1。

int i = 0;
System.out.println(i++);//0
System.out.println(++i);//2

java的前加加和后加加都不能做左值，而C++中前加加可以做左值。

java中的关系操作符

java中的boolean内置类型只能进行==与!=判断，不能进行>,<,>=,<=等判断。

java中的“==”和“!=”如果用在内置类型，判断内置类型的值是否相等；如果用在非内置类型对象，判断对象的引用是否相同。

java中的equals(Object o)方法用来判断对象是否相等，但是需要自己实现equals方法，默认的equals方法比较对象的引用是否相同。

见如下例子：

public class Test5 {
	public static void main(String args[]){
		Integer i1 = new Integer(12);
		Integer i2 = new Integer(12);
		System.out.println(i1.equals(i2));//true
		Stu s1 = new Stu();
		s1.setAge(10);
		Stu s2 = new Stu();
		s2.setAge(10);
		System.out.println(s1==s2);//false
		System.out.println(s1.equals(s2));//true
	}
}
class Stu{
	private int age;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	public boolean equals(Object o){
		Stu s = (Stu)o;
		return s.getAge() == age;
	}
}

java中的逻辑操作符

java中的逻辑操作符产生boolean类型的结果。逻辑操作符只能用在boolean类型间，在java中不能把非boolean类型的变量当作boolean类型用，但是在C和C++中可以。

java中的literal value

int i1 = 0x2f;//16进制
int i2 = 0X2F;//16进制
int i3 = 0123;//8进制
char c1 = 0x2f;
byte b1 = 0x22;
short s1 = 0x4444;
long l1 = 1000l;
long l2 = 1000L;
long l3 = 1000;
float f1 = 1;
float f2 = 1.1f;
float f3 = 1.1F;
double d1 = 1.1;
double d2 = 1.1d;
double d3 = 1.1D;

java中将int或long转成二进制形式

int a = 7;
String ba = Integer.toBinaryString(a);//111
long l = 7;
String bl = Long.toBinaryString(l);//111

如果将byte，char，short传给Integer的toBinaryString方法，则这些类型会自动转成int。

java中的科学计数法

float和double类型的值可以用科学计数法来表示，形如“1.34e10”或“1.34E-10”的形式，这里的e表示以10为底。如果表示float要在后面加上“f”或“F”。

float f5 = 14.543e2f;
double d5 = 1.4543e3;

java中的位操作符

java中的&,|,^可以用于boolean的运算，但是~不能用在boolean类型上，因为避免与！混淆。

对于boolean，位操作符和逻辑操作符的效果一样，只不过不做短路求值。

java中的移位操作符

移位操作符只能用于基本类型中的整型(byte,char,short,int,long)。

>>使用符号扩展，如果是正数则高位补0，负数则补1。

<<在结尾补0。

>>>在高位补0,不管是正数还是负数。

当对byte,char,short类型使用移位操作符时，首先会提升为int，然后再移位，得到的结果是int型。

对int或byte,char,short类型提升后的int移位操作时移位操作符右边的操作数只有最后5位会用到，使用这5位计算出要移的位数，再进行移位操作。比如：

int i = 1;
i = i<<0x3f;
System.out.println(Integer.toBinaryString(i));

结果是10000000000000000000000000000000，说明把1向左移动了31位，只用到了0x3f的最后5位。

如果是long，则只用到右边操作数的后六位。

这是为了避免移动的位数超过或等于int或long的总共的位数。

当我们使用>>>=的形式操作byte或short时可能会出现错误，这是因为它们首先被提升为int，然后移位，然后将int转成byte或short，造成位数的丢失，这会得到错误的-1。比如：

byte b = -1;
b>>>=10;
System.out.println(Integer.toBinaryString(b));//11111111111111111111111111111111
byte c = -1;
System.out.println(Integer.toBinaryString(c>>>10));//1111111111111111111111

下面是正确的值，因为偏移之后对于byte来说越界了，所以再转成byte时出现了错误，得到-1。因此在对byte或short使用>>>=时要小心。

java强制转换

int a = 200;
long lv = (long)a;
long lv1 = (long)200;

从上面可以看出，变量和数值都可以被强制转换。

java允许将除了boolean之外的基本类型转成除了boolean之外的基本类型。

对于class type，java允许父类和子孙类之间的强制转换，子孙类转父类不一定要强制转换，父类转子孙类一定要强制转换，并且父类转子孙类有条件的，父类必须是由子孙类转过来的，才能强制转成子孙类，否则即使强制转化编译没错，运行时也会抛出java.lang.ClassCastException。

java对double和float做四舍五入的方法

使用java.lang.Math类的round()方法，例子如下：

double d1 = 2.3;
		double d2 = 2.6;
		float f1 = 2.3f;
		float f2 = 2.6f;
		System.out.println(Math.round(d1));//2
		System.out.println(Math.round(d2));//3
		System.out.println(Math.round(f1));//2
		System.out.println(Math.round(f2));//3

java没有sizeof

因为java的数据类型在所有的机器上大小是相同的，因此不需要sizeof，c++和c提供sizeof就是为了解决数据类型在不同机器上大小不同的问题。

转载于:https://my.oschina.net/cs7LIl6j/blog/133011