当前位置：文档库 › Java 位运算符

Java 位运算符

Java 定义的位运算（bitwise operators ）直接对整数类型的位进行操作，这些整数类型包括long，int，short，char，and byte 。表4-2 列出了位运算：

表4.2 位运算符及其结果运算符结果

~ 按位非（NOT）（一元运算）

& 按位与（AND）

| 按位或（OR）

^ 按位异或（XOR）

>> 右移

>>> 右移，左边空出的位以0填充

运算符结果

<< 左移

&= 按位与赋值

|= 按位或赋值

^= 按位异或赋值

>>= 右移赋值

>>>= 右移赋值，左边空出的位以0填充

<<= 左移赋值续表既然位运算符在整数范围内对位操作，因此理解这样的操作会对一个值产生什么效果是重要的。具体地说，知道Java 是如何存储整数值并且如何表示

负数的是有用的。因此，在继续讨论之前，让我们简短概述一下这两个话题。所

有的整数类型以二进制数字位的变化及其宽度来表示。例如，byte 型值42的二进制代码是00101010 ，其中每个位置在此代表2的次方，在最右边

的位以20开始。向左下一个位置将是21，或2，依次向左是22，或4，然后是8，16，32等等，依此类推。因此42

在其位置1，3，5的值为1（从右

边以0开始数）；这样42是21+23+25的和，也即是2+8+32 。所有的整数类型（除了char 类型之外）都是有符号的整数。这意味着他们既能表示正数，又能表示负数。Java 使用大家知道的2的补码（two’s complement ）这种编码来表示负数，也就是通过

将与其对应的正数的二进制代码取反（即将1变成0，将0变成1），然后对其结果加1。例如，-42就是通过将42的二进制代码的各个位取反，即对

00101010 取反得到11010101 ，然后再加1，得到11010110 ，即-42 。要对一个负数解码，首先对其所有的位取反，然后加1。

例如-42，或11010110 取反后为00101001 ，或41，然后加1，这样就得到了42。如果考虑到零的交叉

（zero crossing ）问题，你就容易理解Java （以及其他绝大

多数语言）这样用2的补码的原因。假定byte 类型的值零用

00000000 代表。它的补码是仅仅将它的每一位取反，即生成11111111 ，它代表负零。但问题是负零在整数数学中是无效的。为了解决负零的问

题，在使用2的补码代表负数的值时，对其值加1。即负零11111111 加1后为100000000 。但这样使1位太靠左而不适合返回到byte 类

型的值，因此人们规定，-0和0的表示方法一样，-1的解码为11111111 。尽管我们在这个例子使用了byte 类型的值，但同样的基本的原则也适

用于所有Java 的整数类型。因为Java 使用2的补码来存储负数，并且因为Java 中的所有整数都是有符号的，这样应用位运算符可以容易地达到意想不到的结果。例如，不管你如何打算，Java 用高位来代表负数。为避免这个讨厌的意外，请记住不管高位的顺序如何，它决定一个整数的符号。

4.2.1 位逻辑运算符

位逻辑运算符有“与”（AND）、“或

”（OR）、“异或（XOR ）”、“非（NOT）”，分别用“&”、

“|”、“^”、“~”表示，4-3 表显示了每个位逻辑运算的结果。在继续讨论之前，

请记住位运算符应用于每个运算数内的每个单独的位。

表4-3 位逻辑运算符的结果

A 0 1 0 1

B 0 0 1 1 A | B 0 1 1 1 A & B 0 0 0 1 A ^ B 0 1 1

0 ~A 1 0 1 0 按位非（NOT）按位非也叫做补，一元运算符NOT“~”是对其运算数的每一位取反。例如，数字42，它的二进制代码为：00101010 经过按位非运算成为11010101 按位与（AND）按位与运算符

“&”，如果两个运算数都是1，则结果为1。其他情况下，结果均为零。看下面的例子：00101010 42

&00001111 15 00001010 10 按位或（OR）按位或运算符“|”，任何一个运算数为1，则结果为1。如下面的例子所示：00101010 42 | 00001111 15 00101111 47 按位异或（XOR）按

位异或运算符“^”，只有在两个比较的位不同时其结果是1。否则，结果是零。下面的例子显示了

“^”运算符的效果。这个例子也表明了XOR 运算符的一

个有用的属性。注意第二个运算数有数字1的位，42对应二进制代码的对应位是如何被转换的。第二个运算数有数字0的位，第一个运算数对应位的数字不变。当

对某些类型进行位运算时，你将会看到这个属性的用处。00101010 42 ^ 00001111 15 00100101 37

位逻辑运算符的应用下面的例子说明了位逻辑运算符：// Demonstrate the bitwise logical operators.

class BitLogic {

public static void main(String args[]) { String binary[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" };

int a = 3; // 0 + 2 + 1 or 0011 in binary

int b = 6; // 4 + 2 + 0 or 0110 in binary

int c = a | b;

int d = a & b;

int e = a ^ b;

int f = (~a & b) | (a & ~b);

int g = ~a & 0x0f; System.out.println(" a = " + binary[a]); System.out.println(" b = " + binary[b]);

System.out.println(" a|b = " + binary[c]);

System.out.println(" a&b = " + binary[d]);

System.out.println(" a^b = " + binary[e]);

System.out.println("~a&b|a&~b = " + binary[f]); System.out.println(" ~a = " + binary[g]); }

} 在

本例中，变量a与b对应位的组合代表了二进制数所有的 4

种组合模式：0-0，0-1，1-0 ，和1-1 。“|”运算符和“&”运算符分别

对变量a与b各个对应位的运算得到了变量c和变量d的值。对变量e和f的赋值说明了“^”运算符的功能。字符串数组binary 代表了0到15 对应的

二进制的值。在本例中，数组各元素的排列顺序显示了变量对应值的二进制代码。数组之所以这样构造是因为变量的值n对应的二进制代码可以被正确的存储在数组

对应元素binary[n] 中。例如变量a的值为3，则它的二进制代码对应地存储在数组元素binary[3] 中。~a的值与数字0x0f （对应二

进制为0000 1111 ）进行按位与运算的目的是减小~a的值，保证变量g的结果小于16。因此该程序的运行结果可以用数组binary 对应的元素

来表示。该程序的输出如下： a = 0011 b = 0110 a|b = 0111

a&b = 0010 a^b = 0101 ~a&b|a&~b = 0101 ~a = 1100 4.2.2 左移运算符

左移运算符<<使指定值的所有位都左移规定的次数。它的通用格式如下所示：value << num

这

里，num 指定要移位值value 移动的位数。也就是，左移运算符<<使指定值的所有位都左移num位。每左移一个

位，高阶位都被移出

（并且丢弃），并用0填充右边。这意味着当左移的运算数是int 类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long 类型

时，每移动1位它的第63位就要被移出并且丢弃。在对byte 和short类型的值进行移位运算时，你必须小心。因为你知道

Java 在对表达式求值时，将自动把这些类型扩大为int 型，而且，表达式的值也是int 型。对byte 和short类型的值进行移位运算的结

果是int 型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte 或者short类型的值进行移位运算，它被扩

大为int 型后，它的符号也被扩展。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是

将结果转换为byte 型。下面的程序说明了这一点：// Left shifting a byte value.

class ByteShift { public static void main(String args[]) {

byte a = 64, b;

int i; i = a << 2;

b = (byte) (a << 2); System.out.println("Original value of

a: " + a);

System.out.println("i and b: " + i + " " + b);

}

} 该程序产生的输出下所示：Original value of a: 64

i and b: 256 0 因变量a在赋值表达式中，故被扩大为int 型，64（0100 0000 ）被左移两次生成值256 （10000 0000 ）被赋给变量i。然而，经过左移后，变量b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。既然每次左移都可以使原来的操作数翻倍，程序员们经常使用这个办法来进行快速的2 的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点：// Left shifting as a quick way to multiply by 2.

class MultByTwo { public static void main(String args[]) {

int i;

int num = 0xFFFFFFE; for(i=0; i<4; i++) {

num = num << 1;

System.out.println(num); }

}

这

里，num 指定要移位值value 移动的位数。也就是，左移运算符<<使指定值的所有位都左移num位。每左移一个位，高阶位都被移出

（并且丢弃），并用0填充右边。这意味着当左移的运算数是int 类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long 类型

时，每移动1位它的第63位就要被移出并且丢弃。在对byte 和short类型的值进行移位运算时，你必须小心。因为你知道

Java 在对表达式求值时，将自动把这些类型扩大为int 型，而且，表达式的值也是int 型。对byte 和short类型的值进行移位运算的结

果是int 型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte 或者short类型的值进行移位运算，它被扩

将结果转换为byte 型。下面的程序说明了这一点：// Left shifting a byte value.

class ByteShift { public static void main(String args[]) {

byte a = 64, b;

int i; i = a << 2;

b = (byte) (a << 2); System.out.println("Original value of a: " + a);

System.out.println("i and b: " + i + " " + b);

}

} 该程序产生的输出下所示：Original value of a: 64

class MultByTwo { public static void main(String args[]) {

int i;

int num = 0xFFFFFFE; for(i=0; i<4; i++) {

num = num << 1;

System.out.println(num); }

}

} 该程序的输出如下所示：536870908

1073741816

2147483632

-32 初值经过仔细选择，以便在左移4 位后，它会产生-32。正如你看到的，当1被移进31 位时，数字被解释为负值。

4.2.3 右移运算符

右移运算符>>使指定值的所有位都右移规定的次数。它的通用格式如下所示：value >> num 这里，num 指定要移位值value 移动的位数。也就是，右移运算符>>使指定值的所有位都右移num位。下面的程序片段将值32右移2次，将结果8赋给变量a: int a = 32;

a = a >> 2; // a now contains 8 当值中的某些位被

“移出”时，这些位的值将丢弃。例如，下面的程序片段将35右移2 次，它的2个低位被移出丢弃，也将结果8赋给变量a: int a = 35;

a = a >> 2; // a still contains 8 用二进制表示该过程可以更清楚地看到程序的运行过程：00100011 35

>> 2

00001000 8 将值每右移一次，就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然，你一定要确保你不会将该数原有的任何一位移出。右

移时，被移走的最高位（最左边的位）由原来最高位的数字补充。例如，如果要移走的值为负数，每一次右移都在左边补1，如果要移走的值为正数，每一次右移都

在左边补0，这叫做符号位扩展（保留符号位）（sign extension ），在进行右移操作时用来保持负数的符号。例

如，–8 >> 1 是–4，用二进制表示如下：11111000 –8 >>1 11111100 –4 一个要注意的有趣问题是，由于符号位扩展（保留符号位）每次都会在高位补1，因此-1右移的结果总是–1。有时你不希望在右移时保留符号。例如，下面的例子将一个byte 型的值转换为用十六

进制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩展，以便得到的值可以作为定义数组的下标，从而得到对应数组元素代表的十六进制字符。// Masking sign extension.

class HexByte {

static public void main(String args[]) { char hex[] = {

’0’, ’1’, ’2’,

’3’, ’4’, ’5’,

’6’, ’7’,

’8’, ’9’, ’a’,

’b’, ’c’, ’d’,

’e’, ’f’’ };

byte b = (byte) 0xf1; System.out.println("b = 0x" + hex[(b

>> 4) & 0x0f] + hex[b & 0x0f]);}} 该程序的输出如下：b = 0xf1 4.2.4 无符号右移

正

如上面刚刚看到的，每一次右移，>>运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要

的。例如，如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩展（保留符号位）。当你处理像素值或图形时，这种情况是相当普遍的。在这种情况

下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift ）。这时你可以使用

Java 的无符号右移运算符>>> ，它总是在左边补0。下面的程序段说明了无符号右移运算符>>> 。在本例中，变量a被赋值为-1，用二进制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩展，在它的左边总是补0。这样得到的值255被赋给变量a。int a = -1; a = a >>> 24; 下面用二进制形式进一步说

明该操作：11111111 11111111 11111111 11111111 int型-1的二进制代码>>> 24 无符号右移24位00000000 00000000 00000000 11111111 int型255的二进制代码由

于无符号右移运算符>>> 只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表达式中过小的值总是被

自动扩大为int 型。这意味着符号位扩展和移动总是发生在

32位而不是8位或16位。这样，对第7位以0开始的byte 型的值进行无符号移动是不可能

的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点：// Unsigned shifting a byte value.

class ByteUShift {

static public void main(String args[]) {

class HexByte {

static public void main(String args[]) { char hex[] = {

’0’, ’1’, ’2’,

’3’, ’4’, ’5’,

’6’, ’7’,

’8’, ’9’, ’a’,

’b’, ’c’, ’d’,

’e’, ’f’’ };

byte b = (byte) 0xf1; System.out.println("b = 0x" + hex[(b

>> 4) & 0x0f] + hex[b & 0x0f]);}} 该程序的输出如下：b = 0xf1 4.2.4 无符号右移

正

如上面刚刚看到的，每一次右移，>>运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要

下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift ）。这时你可以使用

明该操作：11111111 11111111 11111111 11111111 int型-1的二进制代码>>> 24 无符号右移24位00000000 00000000 00000000 11111111 int型255的二进制代码由

于无符号右移运算符>>> 只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表达式中过小的值总是被

自动扩大为int 型。这意味着符号位扩展和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte 型的值进行无符号移动是不可能

的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点：// Unsigned shifting a byte value.

class ByteUShift {

static public void main(String args[]) {

int b = 2;

int c = 3; a |= 4;

b >>= 1;

c <<= 1;

a ^= c;

System.out.println("a = " + a);

System.out.println("b = " + b);

System.out.println("c = " + c); }

} 该程序的输出如下所示：a = 3

b = 1

c = 6

JAVA运算符和条件结构

运算符和条件结构 3.1 训练的技能点（1）学会使用关系运算符和逻辑运算符（2）学会获取键盘输入的数据（3）学会使用if-else和多重if条件结构（4）学会使用switch结构 3.2 上机任务【阶段一】指导：从键盘获取信息并判断是否合法训练要点（1）键盘输入（2）条件运算符（3）逻辑运算符需求说明（1）录入会员信息（会员号、会员生日、会员积分），并打印输出录入的信息；（2）功能1：判断录入的会员号是否合法（必须为4位整数），如果录入合法，显示录入的信息，如果不合法，则显示“录入信息失败”；实现思路及关键代码（1）创建文件，命名为AddCust.java。（2）实现功能1：使用Scanner获取用户的键盘输入，存储在变量custNo、custBirth、custScore中。Scanner input = new Scanner( System.in ); System.out.println( “请输入会员号<4位整数>：” ); //提示输入4位会员号 int custNo = input.nextInt( ); //从键盘输入会员号，存在变量custNo中注意在使用Scanner前，要在AddCust.java文件开头添加如下代码： import java.util.*; （3）在功能1的基础上实现功能2：判断会员号是否合法。 if ( 会员号有效的条件) {

//输出录入的会员信息 } else { //输出信息录入失败 } 参考解决方案实现功能1： import java.util.*; public class AddCust { public static void main( String[ ] args ) { /* 以下部分是信息输入*/ System.out.println("录入客户信息\n"); //录入客户信息Scanner input = new Scanner( System.in ); System.out.println("请输入会员号(4位数字)："); int custNo = input.nextInt( ); System.out.println("请输入会员生日(月/日<用两位数字表示>)："); String custBirth = input.next(); System.out.print("请输入积分："); int custScore = input.nextInt(); /* 以下部分是信息输出*/ System.out.println("\n已录入的会员信息是："); //显示录入的信息System.out.println(custNo+"\t"+custBirth+"\t"+custScore); } } 实现功能2： import java.util.*; public class AddCust { public static void main( String[ ] args ) { /* 以下部分是信息输入*/ System.out.println("录入客户信息\n"); //录入客户信息Scanner input = new Scanner( System.in ); System.out.println("请输入会员号(4位数字)："); int custNo = input.nextInt( ); System.out.println("请输入会员生日(月/日<用两位数字表示>)：");

java运算符与表达式

一、运算符 1、算术运算符 = - * / %: 例子1：怎样判断两个数是否整除？ public class Helloword { public static void main(String[] args) { int number1=11; int number2=5; if(number1%number2==0){ System.out.println(number1+"与"+number2+"整除！"); }else{ System.out.println(number1+"与"+number2+"不整除！"); } } } 比如：78 7 和8 public class Helloword { public static void main(String[] args) { int number=78; int a=number/10; int b=number%10; System.out.println("a="+a); System.out.println("b="+b); } } 推广：如果是三位数，四位数？…. ++ 例子3：int a=5; Int b=a++; A=? b=? public class Helloword { public static void main(String[] args) { int a = 5; int b = a++;//先赋值b=a，后自增a=a+1 int b2=++a;//先自增a=a+1，再赋值b=a System.out.println("a=" + a);//a=6

System.out.println("b=" + b);//b=5 System.out.println("b2=" + b2);//b=6 } } -- 2、关系运算符 < <= > >= = = != 关系运算的结果：True false 3、逻辑运算符！： &&： ||： ~： public class Helloword { public static void main(String[] args) { if( (10>5) && (10/0==0?true:false) ){ System.out.println("ture"); }else{ System.out.println("false"); } } } 报错！因为：执行(10/0==0?true:false)。 public class Helloword { public static void main(String[] args) { if( (10<5) && (10/0==0?true:false) ){ System.out.println("ture"); }else{ System.out.println("false"); } } } 不报错，因为：没有执行：执行(10/0==0?true:false)。比较两种情况： && ：短路与，只要第一个条件是false，第二个条件不判断& : 与不管第一个条件是什么，第二个条件一样判断

《Java范例开发大全》

下面是377个Java的例子。如果你是牛人，看看你能做出多少？如果有人不相信这些例子都是Java做的，可以看看清华大学的《Java范例开发大全》实例1开发第一个Java程序实例2自动提升实例3自动转换实例4常用基础类型之强制转换实例5算术运算符实例6关系运算符实例7逻辑运算符实例8位运算符实例9移位运算符实例10转型运算符实例11常量与变量实例12各种进制的转换实例13 Java中的进制与移位运算符实例14判断输入的年份是否为闰年实例15抽奖活动实例16xx乘法表实例17如何列出素数实例18 Java中的递归实例19男生女生各多少人

实例20求xx数实例21求任意一个正数的阶乘实例22求n的n次方实例23利用for循环输出几何图形实例24xx 实例25求1到100之间的和实例26存上100元需要多少天实例27输出100之间的所有偶数实例28如何判断回文数字实例29输出100之间的所有奇数实例30求最大的随机数实例31判断字母分类实例32优良及差实例33打印任意一年日历实例34一年四季的划分实例35除0发生的算术异常（ArithmeticException）实例36数组下标越界异常（ArrayIndexOutOfBoundsException）实例37数组元素类型不匹配异常（ArrayStoreException）实例38强制类型转换异常（ClassCastException）实例39索引越界异常（IndexOutOfBoundsException）实例40空指针异常（NullPointerException）

java移位运算符详解

java移位运算符不外乎就这三种：<<（左移）、>>（带符号右移）和>>>（无符号右移） 1、左移运算符左移运算符<<使指定值的所有位都左移规定的次数。 1）它的通用格式如下所示： value << num num 指定要移位值value 移动的位数。左移的规则只记住一点：丢弃最高位，0补最低位如果移动的位数超过了该类型的最大位数，那么编译器会对移动的位数取模。如对int 型移动33位，实际上只移动了33%32=1位。 2）运算规则按二进制形式把所有的数字向左移动对应的位数，高位移出(舍弃)，低位的空位补零。当左移的运算数是int 类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long 类型时，每移动1位它的第63位就要被移出并且丢弃。当左移的运算数是byte 和short类型时，将自动把这些类型扩大为 int 型。 3）数学意义在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2的1次方，左移n位就相当于乘以2的n次方 4）计算过程：例如：3 <<2(3为int型) 1）把3转换为二进制数字0000 0000 0000 0000 0000 0000 0000 0011， 2）把该数字高位(左侧)的两个零移出，其他的数字都朝左平移2位， 3）在低位(右侧)的两个空位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 1100，转换为十进制是12。移动的位数超过了该类型的最大位数，如果移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点： Java代码 // Left shifting as a quick way to multiply by 2. public class MultByTwo { public static void main(String args[]) { int i; int num = 0xFFFFFFE; for(i=0; i<4; i++) { num = num << 1;

java中常见的几种运算符

Java中常见的几种运算符第一：算术运算符：{+、-、*、/、%取余或是取模、++与--递增和递减。} 需要注意的几个地方：在进行除法运行时当两个整数相除时结果为整数，若除以一个整数除不尽时，这是就会返回整数部分，小数部分则将省略，这时就要涉及到浮点型数据了！递增和递减应注意的是：++或—写在变量前面，则该式子的值等于变量变化以前的值。2）++或—写在变量后面，则该式子的值等于变量变化以后的值。第二：关系运算符：{==等于若两个值相等，返回一个真值、!=不等于、<小于、>大于、<=小于等于、>=大于等于}主要用于根据某个变量的值来执行特定的操作，并且返回一个布尔值，一般形式为：做操作数关系运算符右操作数！第三：位运算符：{“&”代表与运算符两个条件都成立才算成立；“︳”代表或运算符，满足其中一个即可成立，对应的二进制位有一个为1 则为1，否则为0；“?”代表异或运算符，对应的二进制位相同为零，不相同为1}

第四：逻辑运算符：{“&&”代表与逻辑运算符两个条件都成立算成立，“︳︳”代表或逻辑运算符，满足其中一个条件即可，他们的结果都是boolean类型的ture或false} 第五：移位运算符：{“<<”代表向左移多少位；“>>”代表向又移多少位；“>>>”又移补零} 按二进制形式把所有的数字向左移动对应的位数，高位移出(舍弃)，低位的空位补零。语法格式：需要移位的数字<<（>>）移位的次数在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2 的1 次方，左移n 位就相当于乘以2 的n 次方；右移n 位相当于除以2 的n 次方。如：b<<8相当于b*16;b>>8相当于b/16. 第六：三元运算符{语法格式：（布尔表达式）？（真值）：（假植）}如果布尔表达式的条件为真那么执行的条件位真值，否则反之。【a=a+5等于a+=5】第七：运算符的优先级： 1 () [] . 从左到右 2 ! +(正) -(负) ~ ++ -- 从右向左 3 * / % 从左向右 4 +(加) -(减) 从左向右 5 << >> >>> 从左向右

JAVA语言中常用的运算符

JAVA中常用的运算符有以下几种我们日常了解到的运算符有有+（加号）、-（减号）、*（乘号）、/（除号）和%（求余），那么在JAVA中有哪些我们不知晓的运算符呢，下面就介绍下JAVA中的运算符。一、自增和自减运算符自增、自减运算符是单目运算符，可以放在操作元之前，也可以放在操作元之后。操作元必须是一个整型或浮点型变量。放在操作元前面的自增、自减运算符，会先将变量的值加1（减1），然后再使该变量参与表达式的运算；放在操作元后面的自增、自减运算符，会先使变量参与表达式的运算，然后再将该变量加1（减1）。二、算术运算符 ava中的算术运算符主要有+（加号）、-（减号）、*（乘号）、/（除号）和%（求余），它们都是二元运算符。三、比较运算符比较运算符属于二元运算符，用于程序中的变量和变量之间、变量和常量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型，当运算符对应的关系成立时，运算结果是true，否则结果是false。比较运算符通常用在条件语句中来作为判断的依据。四、逻辑运算符逻辑运算符包括&&（&）（逻辑与）、||（|）（逻辑或）和!（逻辑非），返回值为布尔类型的表达式，操作元也必须是boolean型数据。

和比较运算符相比，逻辑运算符可以表示更加复杂的条件，例如连接几个关系表达式进行判断。在逻辑运算符中，除了“！”是一元运算符之外，其余的都是二元运算符。五、位运算符位运算符用于处理整型和字符型的操作数，对其内存进行操作，数据在内存中以二进制的形式表示，例如int型变量7的二进制表示是00000000 00000000 00000000 00000111，-8的二进制表示是111111111 111111111 1111111 11111000，最高位是符号位，0表示正数，1表示负数。六、运算符优先级七、三元运算符三元运算符是Java中唯一一个三目运算符，其操作元有三个，第一个是条件表达式，其余的是两个值，条件表达式成立时运算取第一个值，不成立时取第二个值，示例代码如下所示： boolean b = 20 < 45 ? true : false;

Java上机作业2_运算符和表达式分析

第三章运算符和表达式一、大纲 1.理解表达式以及其相关概念 2.掌握算术赋值等运算符的使用二、实验目标： 1.掌握表达式，优先级，结合性的概念。 2.掌握算数，赋值，增减量，逗号表达式的使用。 3.理解类型转换的含义和使用方法。 4.掌握输入输出运算符的使用。 5.能使用输入输出运算符结合变量和算术、赋值等运算符实现一个简单的现实功能。三、实验方式：要求学生自己独立完成四、任务 4.1任务1：使用变量参与各种运算（时间：40分钟） 4.1.1.2（20分钟）要求从键盘上接收三个整数a，b，c，分别求++a + b + c，a++ + b + c++,a + b++ + ++c 和++a + ++b + ++c的和，并将其输出。 a=1 b=2 c=3

4.1.2 任务目的 (1)理解变量在未被初始化的情况下其值随机。 (2)理解增量运算符的运算规则。 (3)理解优先级的概念。 4.1.3 任务要求 (1)先分析程序的执行结果，以及每一步语句执行后程序中各自变量的变化情况。 (2)如果分析有困难，可以先查看执行结果，再分析程序的执行情况。 4.1.4 难点提示前++和后++的运算规则，以及优先级概念。 4.2任务2：变量与输入输出运算符的结合使用（时间：70分钟） 4.2.1 任务描述 4.2.1.1（15分钟） (1)分别定义三个int变量，从键盘上接收三个整数，然后对它们求和，输出求和结果。 (2)注意需要将求和的结果另外保存到一个变量中，然后再执行输出操作。 4.2.1.2（20分钟）定义一个int类型的变量a，并从键盘接收一个整数，将其赋予a，定义一个float类型的变量b，并从键盘接收一个浮点数，将其赋予b，再定义一个float类型的变量c，计算a+b 的值，并将其赋予c。 4.2.1.3（15分钟）编写一个程序，该程序要求输入一个float类型的数字并打印该数的立方值，并将其立方值赋给一个int类型的变量,打印该int类型的值。

java运算符基础入门

1 运算符 1：运算对常量和变量进行操作的过程称为运算。 2：运算符对常量和变量进行操作的符号称为运算符 3：操作数参与运算的数据称为操作数 4：用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。不同运算符连接的式子体现的是不同类型的表达式。举例： int a = 3 + 4; 这是做了一个加法运算 +就是运算符，是算术运算符，我们还有其他很多的运算符 3，4就是参与运算的操作数据 3 + 4整体其实就是一个算数表达式

●+,-,*,/都是比较简单的操作，简单演示即可 ●+的几种作用： ?加法 ?正数 ?字符串连接符 ●除法的时候要注意一个问题： ?整数相除，只能得到整数 ?要想得到小数，可以*1.0 ●/和%的区别 ●++和--的应用 ?单独使用效果相同 ?参与运算使用，在操作数的前后效果不同●1:基本小题目 ●int a = 10; ●int b = 10; ●int c = 10; ● a = b++; ● c = --a; ● b = ++a; ● a = c--; ●请分别计算出a,b,c的值 ●2:比较复杂的题目 ●int a = 4; ●int b = (a++)+(++a)+(a*10); ●引出运算符的优先级

2 赋值运算符 ●符号： ?= , +=, -=, *=, /=, %= ?=为基本的赋值运算符，其他的为扩展的赋值运算符 ●如下操作写出结果 ?int a,b; a = b = 10; ?System.out.println(a); System.out.println(b); ?int a = 10; a += 20; System.out.println(a); ●面试题 ?short s=1, s = s+1; short s=1, s+=1; ?上面两个代码有没有问题，如果有，那里有问题 1:= 赋值号 2:+=加赋值把左边和右边的结果赋值给左边。注意：左边不能是常量 3:通过面试题引出+=运算符的特点：有一个隐含的默认转换功能。实际上等价于： short s = 1; s+=1等价于 s=(s的数据类型)(s+1 关系运算符

Java移位运算符

JAVA基础(JAVA移位运算符) . 移位运算符就是在二进制的基础上对数字进行平移。按照平移的方向和填充数字的规则分为三种：<<（左移）、>>（带符号右移）和>>>（无符号右移）。在移位运算时，byte、short和char类型移位后的结果会变成int类型，对于byte、short、char和int进行移位时，规定实际移动的次数是移动次数和32的余数，也就是移位33次和移位1次得到的结果相同。移动long型的数值时，规定实际移动的次数是移动次数和64的余数，也就是移动66次和移动2次得到的结果相同。三种移位运算符的移动规则和使用如下所示： <<运算规则：按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零。语法格式：需要移位的数字<<移位的次数例如：3 << 2，则是将数字3左移2位计算过程： 3 << 2 首先把3转换为二进制数字0000 0000 0000 0000 0000 0000 0000 0011，然后把该数字高位（左侧）的两个零移出，其他的数字都朝左平移2位，最后在低位（右侧）的两个空位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 1100，则转换为十进制是12.数学意义：在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2

的1次方，左移n位就相当于乘以2的n次方。 >>运算规则：按二进制形式把所有的数字向右移动对应巍峨位数，低位移出（舍弃），高位的空位补符号位，即正数补零，负数补1. 语法格式：需要移位的数字>>移位的次数例如11 >> 2，则是将数字11右移2位计算过程：11的二进制形式为：0000 0000 0000 0000 0000 0000 0000 1011，然后把低位的最后两个数字移出，因为该数字是正数，所以在高位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 0010.转换为十进制是3.数学意义：右移一位相当于除2，右移n位相当于除以2的n次方。 >>>运算规则：按二进制形式把所有的数字向右移动对应位数，低位移出（舍弃），高位的空位补零。对于正数来说和带符号右移相同，对于负数来说不同。其他结构和>>相似。小结二进制运算符，包括位运算符和移位运算符，使程序员可以在二进制基础上操作数字，可以更有效的进行运算，并且可以以二进制的形式存储和转换数据，是实现网络协议解析以及加密等算法的基础。实例操作： public class URShift { public static void main(String[] args) { int i = -1; i >>>= 10;

JAVA运算符

JAVA运算符 JA V A有4大运算符，算术运算、位运算、关系运算、逻辑运算 1算术运算符序号运算符含义 1 + 加法 2 - 减法 3 * 乘法 4 / 除法 5 % 模运算（取余运算） 6 ++ 递增运算 7 -- 递减运算 8 += 加法赋值 9 -= 减法赋值 1、加法运算符，相当于 1 + 1 = 2（补充浮点数与整数、整数与整数、浮点数与浮点数之间的运算） 2、减法运算符，相当于 2 – 1 = 1 3、乘法运算符，相当于 2 * 2 = 4 4、除法运算符，相当于 4 / 2 = 2 5、取模运算符，其运算结果是整数除法的余数，它还能被用于浮点类型数的取余运算。 public static void main(String[] args) { 1、System.out.println(5 % 2); //整数运算取余 2、System.out.println(2.0 % 1.0); //浮点数运算取余 } 运算结果第一行为1 ，第二行为0.0 6、递增运算符， 1）、 a = x ++ , x++ 不增值。可以看做a = x ; x = x + 1 2）、 a = ++x , ++x 增值。可以看做a = x + 1; x = x + 1 7、递减运算符 1)、 a = x -- , x-- 不减值。可以看做 a = x ; x = x - 1 2)、 a = --x , --x 减值。可以看做a = x – 1 ; x = x - 1

8、加法赋值符，例如x += 1 , 相当于x = x + 1 9、减法赋值符，例如x -=1 , 相当于x = x - 1 注：JA V A运算符的优先级运算符的优先级决定了多个运算符在一个表达式中运算的顺序，其中最简单的是乘除的优先级大于加减。而一旦表达式比较复杂时，程序员经常会忘记其他优先级规则，所以应该用括号明确规定计算顺序。例：int a = 100 - 12.5 * 3 + 5 / 2 + 2 ; 这个表达式的顺序如果不加打括号，任何人都会先计算乘除，然后才计算加减。而只要加上括号后，这个表达式就有了个不同的含义。比如：int a = (100 – 12.5) * 3 + 5 / (2 + 2) 2基本数据类型之间的运算 2.1 整数与整数整数与整数之间的运算规则如下： int/long a 运算符int/long b 结果 2 + 4 6 4 - 2 2 2 * 4 8 5 / 2 2 5 % 2 1 说明：整数与整数之间的计算，加法、减法、乘法和普通数学运算没什么区别，但是在除法中，碰到有余数时，结果只取完整结果的整数部分。如果整型和长整型的数计算的话，计算结果的类型是长整形。 2.2 整数与浮点数整数与整数之间的运算规则如下： int/long a 运算符float/double b 结果 2 + 4.2 6.2 4 - 2.3 1.72 2 * 4.45 8.9

java运算符大全

一、算术运算符：单目：+(取正)-(取负) ++(自增1) - -(自减1) 双目：+ - * / %(取余) 三目：a>b?true:false 说明：当a大于b的时候，为true(也就是冒号之前的值)，否则为false;这整个运算符包括一个关系运算符(可以是">""<""!="等等)，一个"?",一个":",冒号前后需要有两个表达式或者是值或者是对象。二、关系运算：等于符号：==,不等于符号：!= ,大于符号：>, 小于符号：<,大于等于符号：>= ,小于等于符号：<= . 三、位运算符逻辑运算符：位运算符与(&)、非(~)、或(|)、异或(^)&:当两边操作数的位同时为1时，结果为1,否则为0.如1100&1010=1000 | :当两边操作数的位有一边为1时，结果为0,否则为 1.如1100|1010=1110 ~:0变1,1变0 ^:两边的位不同时，结果为1,否则为0.如1100^1010=0110 逻辑运算符与(&&)、非(!)、或(||) 四、赋值运算符 = += -= *= /= %= &= ^= |= 《= 》= 五、instanceof运算符该运算符是双目运算符，左面的操作元是一个对象，右面是一个类。当左面的对象是右面的类创建的对象时，该运算符运算结果是true,否则是false. 六、运算符综述 Java 的表达式就是用运算符连接起来的符合Java 规则的式子。运算符的优先级决定了表达式中运算执行的先后顺序。例如，x 运算符的结合性决定了并列相同级别的运算符的先后顺序，例如，加减的结合性是从左到右，8-5+3 相当于(8-5)+3.逻辑否运算符的结合性是右到左，x 相当于!(!x)。表3.4是Java 所有运算符的优先级和结合性。七位移运算符《带符号左移》带符号右移>>>无号右移例子：int a1 = 8; // 0000 0000 0000 1000 System.out.println(a1>>>2); //// 0000 0000 0000 0010 输出为2 运算符优先级按优先级从高到低排列如下：[ ]、( )、++、--、!、~、instanceof、*、/、%、+、-、《、》、>>>、<>、<、=、>、\、==、!=、&、^、&&、||、? :、= . Java强制类型转换强制和转换 Java语言和解释器限制使用强制和转换，以防止出错导致系统崩溃。整数和浮点数运算符间可以来回强制转换，但整数不能强制转换成数组或对象。对象不能被强制为基本类型。Java中整数运算符在整数运算时，如果操作数是long类型，则运算结果是long类型，否则为int类型，绝不会是byte,short或char型。这样，如果变量i被声明为short或byte,i+1的结果会是int.如果结果超过该类型的取值范围，则按该类型的最大值取模。运算符操作一、运算符"+",如果必要则自动把操作数转换为String型。如果操作数是一个对象，它可定义一个方法toString()返回该对象的String方式，例如floata=1.0print("Thevalueofais"+a+"\n");+运算符用到的例子Strings="a="+a;+=运算符也可以用于String.注意，左边(下例中的s1)仅求值一次。s1+=a;//s1=s1+a//若a非String型，自动转换

Java的位运算符详解整理得比较全

Java的位运算符详解实例——与（&）、非（~）、或（|）、异或（^）位运算符主要针对二进制，它包括了：“与”、“非”、“或”、“异或”。从表面上看似乎有点像逻辑运算符，但逻辑运算符是针对两个关系运算符来进行逻辑运算，而位运算符主要针对两个二进制数的位进行逻辑运算。下面详细介绍每个位运算符。 1．与运算符与运算符用符号“&”表示，其使用规律如下：两个操作数中位都为1，结果才为1，否则结果为0，例如下面的程序段。 public class data13 { public static void main(String[] args) { int a=129; int b=128; System.out.println("a 和b 与的结果是："+(a&b)); } } 运行结果 a 和 b 与的结果是：128 下面分析这个程序： “a”的值是129，转换成二进制就是10000001，而“b”的值是128，转换成二进制就是10000000。根据与运算符的运算规律，只有两个位都是1，结果才是1，可以知道结果就是10000000，即128。 2．或运算符或运算符用符号“|”表示，其运算规律如下：两个位只要有一个为1，那么结果就是1，否则就为0，下面看一个简单的例子。

public class data14 { public static void main(String[] args) { int a=129; int b=128; System.out.println("a 和b 或的结果是："+(a|b)); } } 运行结果 a 和 b 或的结果是：129 下面分析这个程序段： a 的值是129，转换成二进制就是10000001，而 b 的值是128，转换成二进制就是10000000，根据或运算符的运算规律，只有两个位有一个是1，结果才是1，可以知道结果就是10000001，即129。 3．非运算符非运算符用符号“~”表示，其运算规律如下：如果位为0，结果是1，如果位为1，结果是0，下面看一个简单例子。 public class data15 { public static void main(String[] args) { int a=2; System.out.println("a 非的结果是："+(~a)); } } 4．异或运算符异或运算符是用符号“^”表示的，其运算规律是：

Java运算符之算术运算符

序号运算符含义 1 + 加法 2 - 减法 3 * 乘法 4 / 除法 5 % 模运算(取余运算) 6 ++ 递增运算 7 -- 递减运算 Java的算术运算符分为一元运算符和二元运算符。一元运算符只有一个操作数；二元运算符有两个操作数，运算符位于两个操作数之间。算术运算符的操作数必须是数值类型。 (1)一元运算符一元运算符有：正(+)、负(-)、自增(++)和自减(--)4个。自增和自减运算符只允许用于数值类型的变量，不允许用于表达式中。该运算符既可放在变量之前(如++i)，也可放在变量之后(如i++)，两者的差别是：如果放在变量之前(如++i)，则变量值先加1或减1，然后进行其他相应的操作(主要是赋值操作)；如果放在变量之后(如i++)，则先进行其他相应的操作，然后再进行变量值加1或减1。例如： int i=6，j，k，m，n; j = +i; //取原值，即j=6 k = -i; //取负值，即k=-6 m = i++; //先m=i,再i=i+1，即m=6，i=7 m = ++i; //先i=i+1,再m=i，即i=7，m=7 n = j--; //先n=j,再j=j-1，即n=6，j=5 n = --j; //先j=j-1,再n=j，即j=5，n=5

在书写时还要注意的是：一元运算符与其前后的操作数之间不允许有空格，否则编译时会出错。 (2)二元运算符二元运算符有：加(+)、减(-)、乘(*)、除(/)、取模(%)。其中+、-、*、/完成加、减、乘、除四则运算，%是求两个操作数相除后的余数。 %求余操作举例： a % b = a - (a / b) * b 取余运算符既可用于两个操作数都是整数的情况，也可用于两个操作数都是浮点数(或一个操作数是浮点数)的情况。当两个操作数都是浮点数时，例如7.6 % 2.9时，计算结果为：7.6 - 2 * 2.9 = 1.8。当两个操作数都是int类型数时，a%b的计算公式为： a % b = a - (int)(a / b) * b 当两个操作数都是long类型(或其他整数类型)数时，a%b的计算公式可以类推。当参加二元运算的两个操作数的数据类型不同时，所得结果的数据类型与精度较高(或位数更长)的那种数据类型一致。例如： 7 / 3 //整除，运算结果为2 7.0 / 3 //除法，运算结果为2.33333,即结果与精度较高的类型一致 7 % 3 //取余，运算结果为1 7.0 % 3 //取余，运算结果为1.0 -7 % 3 //取余，运算结果为-1，即运算结果的符号与左操作数相同 7 % -3 //取余，运算结果为1，即运算结果的符号与左操作数相同注：JAVA运算符的优先级运算符的优先级决定了多个运算符在一个表达式中运算的顺序，其中最简单的是乘除的优先级大于加减。而一旦表达式比较复杂时，程序员经常会忘记其他优先级规则，所以应该用括号明确规定计算顺序。

Java基础篇—运算符

Java基础篇—运算符 Java运算符按功能可分为：算数运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和条件运算符。算数运算符算术运算符包括通常的加（+）、减（-）、乘（*）、除（/）、取模（%），完成整数型和浮点型数据的算术运算。许多语言中的取模运算只能用于整数型，Java对此做了扩展，它允许对浮点数进行取模操作。例如，3%2的结果是1,15.2%5的结果是0.2。取模操作还可以用于负数，结果的符号与第一个操作数的符号相同，例如，5%-3的结果是2，-5%3的结果是-2。此外，算术运算符还有“++”和“--”两种，分别称为加1和减1运算符。这两种运算符有前缀形式和后缀形式，含有有所不同。例如，i++和++i的执行顺序是不一样的，i++在i 使用之后再+1，++i在i使用之前先+1。i--和--i的情况于此类似。关系运算符关系运算符用来比较两个值，包括大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）和不等于（!=）6种。关系运算符都是二元运算符，也就是每个运算符都带有两个操作数，运算的结果是一个逻辑值。Java允许“==”和“!=”两种运算符用于任何数据类型。例如，既可以判断两个数的值是否相等，也可以判断对象或数组的实例是否相等。判断实例时比较的是两个对象在内存中的引用地址是否相等。逻辑运算符逻辑运算符包括逻辑与（&&）、逻辑或（||）和逻辑非（!）。前两个是二元运算符，后一个是一元运算符。Java对逻辑与和逻辑或提供“短路”功能，也就是在进行运算时，先计

算运算符左侧的表达式的值，如果使用该值能得到整个表达式的值，则跳过运算符右侧表达式的计算，否则计算运算符右侧表达式，并得到整个表达式的值。位运算符位运算符用来对二进制位进行操作，包括按位取反（~）、按位与（&）、按位或（|）、异或（^）、右移（>>）、左移（<<）和无符号右移（>>>）。位运算符只能对整数型和字符型数据进行操作。 1.取反（~）参加运算的一个数据，按二进制位进行“取反”运算。运算规则：~1=0；~0=1；即：对一个二进制数按位取反，即将0变1，1变0。 2.按位与（&）参加运算的两个数据，按二进制位进行“与”运算。

Java运算符实训

实训三熟悉使用运算符和表达式一、算术运算符 1、注意事项：（1）、不同数据类型进行算术运算时遵循自然转换的规则（2）、整除（/）号运算规律：如果两天操作数是泛整型，则结果为泛整型；如果两边操作数又一个位浮点型，则结果为浮点型。（3）、取模号（%）运算规律：它的操作数可以是浮点型。其它同整除号。（4）、X++.x--，后置运算，先自增/减一，再参与运算，； ++x --x，前置运算，想参与运算，再自增/减一注意：----有时上面例子也不是绝对的。同样的程序在不同的编译器下（如C或者VC等），运行会得到不同的结果，值得提出的是，不同的编译器会有不同的编译形式！二、位运算符补码知识：原码：数值转换成对应的二进制数，反码：原码按位取反补码：反码加1 计算机使用二进制补码表示数值，其中最高位为符号位，正数符号位为0，负数符号位为1.。正负数的补码规则如下：正数的原码、反码和补码相同负数的反码为该数绝对值的原码按位取反，补码为反码加1.。三、混合运算符练习：写出结果，并进行上机检验已知：a=4,b=10,c=3; 1、z=(float)(a+b)/c+(b-a)%a; 2、z=b-a==c&&--c>1; 四、作业单元案例题目：设计一个判断是否是闰年的表达式

设计要求：判断一个年份是否是闰年的条件为： 1、每隔4年有一个闰年（能被4整除的） 2、每隔100年要去除一个闰年 3、每400年要再增加一个闰年设计提示：考察逻辑运算符（&&和||）的使用三个判断表达式分别为： 1、year%4==0 2、year%100！==0 3、year%400==0

JAVA编程题全集(50题及答案)

【程序1】?题目：古典问题:有一对兔子，从出生后第３个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月得兔子总数为多少？ //这就是一个菲波拉契数列问题?publiｃclaｓs liａnxi０1 ｛?publiｃｓｔaｔiｃvoid main（Str ｉｎg［]aｒgs) ｛Ｓysｔem、out、ｐｒintln（＂第1个月得兔子对数：1”)； Sｙsｔｅｍ、ｏut、prｉｎｔln(＂第2个月得兔子对数：1"）；?inｔｆ1= 1, f2＝１, ｆ，M=24;?for(int i=3; ｉ〈=M；ｉ++）{ f=f2；ｆ２= ｆ1+ f2；?ｆ1 = f; Ｓystem、ouｔ、println（”第" ＋i ＋"个月得兔子对数：”+ｆ２); }?｝ } 【程序2】?题目：判断１01-2０0之间有多少个素数，并输出所有素数. 程序分析:判断素数得方法：用一个数分别去除２到sｑrt（这个数），如果能被整除，则表明此数不就是素数,反之就是素数。ｐｕｂlｉc ｃlaｓs liaｎxi02 ｛ｐｕblic statｉc ｖoid main(Strinｇ[］argｓ）{ ｉnt count = 0; for(inｔｉ=１０1; i〈2０0；i＋＝２）{ bｏoｌeａn ｂ=faｌse； for(ｉｎt ｊ=2; j〈=Math、sqrt（i）；j+＋) { iｆ（i%j ==0）｛ b = faｌsｅ；breaｋ；｝?eｌse { b =tr ｕe；｝｝ if(ｂ＝= truｅ) ｛coｕnt ++;Systｅm、ｏut、println（i ）;} ｝ Sysｔem、ouｔ、pｒintln( ＂素数个数就是:"＋count）; ｝?｝【程序3】题目：打印出所有得"水仙花数”,所谓"水仙花数”就是指一个三位数，其各位数字立方与等于该数本身。例如:1５３就是一个＂水仙花数”,因为153=1得三次方+５得三次方＋3得三次方。ｐubliｃclａsｓlｉanxi03 ｛?pｕblic statｉｃvoidｍａin（Ｓtrinｇ［] argｓ) ｛int b1，b2，ｂ３；?fｏr(int m=1０1；m<1０0０；m+＋）{ b3 =m ／100；?ｂ2=ｍ％1０0／10；?ｂ1 =m％1０；?if（(b3＊b3*b３+b2*b2＊b2 + b１＊ｂ1*b1) == m）｛?Syｓｔem、ouｔ、pr ｉntln(m＋"就是一个水仙花数”)；｝?} }?｝【程序4】题目:将一个正整数分解质因数.例如:输入90,打印出90=２＊3*3*5。程序分析:对ｎ进行分解质因数，应先找到一个最小得质数k，然后按下述步骤完成：?（1)如果这个质数恰等于n，则说明分解质因数得过程已经结束，打印出即可. ?（2）如果n <〉

Java中包含哪些运算符

Java中包含哪些运算符? 在Java中包含的运算符有：算数运算符，逻辑运算符，关系运算符等。算数运算符也就是我们平时的加减乘除余等操作：在Java中都是将右边的值赋值给左边，所以一般格式为：结果= 值; 加(+)：result = value1 + value2;例如result = 10 + 10;结果result值为20; 减(-)：result = value1 - value2; 例如result = 20 - 10; 结果result值为10; 乘(*)：result = value1 * value2; 例如result = 20 * 10; 结果result值为200; 除(/)：result = value1 / value2; 例如result = 20 / 10;结果result值为2;如果value2的值为0，则Java会抛出一个异常; 余(%)：求余，即获取不能除尽的值，result = value1 % value2;例如result = 12 % 5;result结果为2; 自增(++)：value++或者++value;意思是将value的值加1;自增有两种写法，一种是++在前面，一种是++在后面，这两种单独使用的时候没有区别，但是和其他变量或者其他语法一起使用的时候，就有区别了，++在前说明是先将value加1然后在计算;++在后面说明先使用value 在进行value加1;例如value = 10;result = value++; result的结果为10，value结果为11，因为++在后面所以先使用value赋值给result，然后value在进行加1;在如：result = ++value; result 的结果为11，value的结果为11;因为++在前面，所以value值先加一变成了11，然后再将value值赋值给result，所以result的结果为11; 自减(--):与自增一样的逻辑，只不过是将自身进行减1; 逻辑运算符：&&(并且) ||(或) !(非)，逻辑运算符判断的变量为boolean,只有true与false;

java中的自增(++)和自减(--)运算符

有些运算符在JAVA语言中存在着，但是在实际开发中我们或许很少用到它们，在面试题中却时常出现它们的身影，对于这些运算符的含义和用法，你是否还记得呢？自增（++）和自减（--）运算符我们先来回答几个问题吧： Java代码 1.int i = 0; 2.int j = i++; 3.int k = --i; 这段代码运行后，i等于多少？j等于多少？k等于多少？太简单了？好，继续： Java代码 1.int i = 0; 2.int j = i++ + ++i; 3.int k = --i + i--; 代码执行后i、j、k分别等于多少呢？还是很简单？好，再继续： Java代码 1.int i=0; 2.System.out.println(i++); 这段代码运行后输出结果是什么？0？1？ Java代码 1.float f=0.1F; 2.f++; 3.double d=0.1D; 4.d++; 5.char c='a'; 6.c++; 上面这段代码可以编译通过吗？为什么？如果你能顺利回答到这里，说明你对自增和自减运算符的掌握已经很好了。为了分析出上面提出的几个问题，我们首先来回顾一下相关知识：

?自增（++）：将变量的值加1，分前缀式（如++i）和后缀式（如i++）。前缀式是先加1再使用；后缀式是先使用再加1。 ?自减（--）：将变量的值减1，分前缀式（如--i）和后缀式（如i--）。前缀式是先减1再使用；后缀式是先使用再减1。在第一个例子中，int j=i++;是后缀式，因此i的值先被赋予j，然后再自增1，所以这行代码运行后，i=1、j=0；而int k=--i;是前缀式，因此i先自减1，然后再将它的值赋予k，因此这行代码运行后，i=0、k=0。在第二个例子中，对于int j=i++ + ++i;，首先运行i++，i的值0被用于加运算（+），之后i自增值变为1，然后运行++i，i先自增变为2，之后被用于加运算，最后将i两次的值相加的结果1+2=3赋给j，因此这行代码运行完毕后i=2、j=2；对于int k=--i + i--;用一样的思路分析，具体过程在此不再赘述，结果应该是i=0、k=2。自增与自减运算符还遵循以下规律： 1.可以用于整数类型byte、short、int、long，浮点类型float、double，以及字符串类型char。 2.在Java5.0及以上版本中，它们可以用于基本类型对应的包装器类Byte、 Short、Integer、Long、Float、Double、Character。 3.它们的运算结果的类型与被运算的变量的类型相同。下面的这个例子验证以上列出的规律，它可以编译通过并执行。 Java代码 1.public class Test { 2. public static void main(String[] args) { 3. // 整型 4. byte b = 0; 5. b++; 6. // 整型 7. long l = 0; 8. l++; 9. // 浮点型 10. double d = 0.0; 11. d++; 12. // 字符串 13. char c = 'a'; 14. c++; 15. // 基本类型包装器类 16. Integer i = new Integer(0); 17. i++;