Javaの開発経験の数学的応用-java
コンピュータにデジタル形式で格納されています
参考：
https://blog.csdn.net/alpinistwang/article/details/87994617
1个字节是8位
只有8种基本类型可以算.其他引用类型都是由java虚拟机决定的自己不能操作
byte 1字节
short 2字节
int 4字节
long 8字节
float 4字节
double 8字节
char 2字节
boolean 1字节
1111 Fのバイナリコード
0111 7のバイナリコード
結果、全体の二進整数表現は、第0x7FFFFFFFで他に1、残りがあり、0であります
INT進数：32
短い進数：16
長いバイナリ桁数：64
二進数をフロート：32
ダブル進数：64
バイナリ1つのint型4バイト、8ビットのバイト、32ビットの総数を格納するコンピュータのint型データ。
（1）最初のフラグであり、フラグビットフラグ1が陰性を示し、正の0です。
（2）残りの31ビットは、デジタル部分を表すために使用されています
原則として、最初のフラグ、数値を格納するための唯一の31ビットの値であり、デジタルコンピュータを格納します。2 ^ 31-1：だから、最大の正の数は、つまり0,111,111,111,111,111 1,111,111,111,111,111、によって表されます
int型2進数を回します
public static void main(String[] args) {
int a = 7;
String binaryString = Integer.toBinaryString(a);
System.out.println(binaryString);
}出力：
111
コンピュータのメモリ
プリミティブ
コンピュータメモリ内のint型バイナリデータ、データ型int 4バイト、8ビットのバイト、32ビットの合計。
（1）最初のフラグであり、フラグビットフラグ1が陰性を示し、正の0です。
（2）残りの31ビットは、デジタル部分を表すために使用されています
補完
デジタルストレージを補完するために、コンピュータで。自体を補完する、負の補数フラグはまた、他のビットとビット単位で正です。
特性補数
図1に示すように、負の整数（または元コード）およびその補数（または補体）を加え、そして鋳型の通りです。
図2に示すように、補整数が補完され、整数自体次いで、等しいです。
図3に示すように、正および負のゼロゼロ補数表現同じ。
金型は24に等しい時間に0から23のクロックに測定範囲、。：17点時針に現在の点を仮定し、正確な時刻が9:00であり、時間調整は、次の2つの方法を有することができ、
1反転ダイヤル8時間、即ち：= 9 17--8と、
2つのシスは16時間ダイヤル：17 + 16 = 33 ; 33％= 24 9
この例では、16 -8、24の補数で表現されます。図16と利益-8を加えに引き算です。
正と負の数が示されている場合、コンピュータは、別の元のコードを処理する加算および減算演算を実行する必要があります。そして、あなたは、加算と減算の演算を使用しているコンピュータの負担を軽減するコンピュータへの補数表現、ユニファイドコンピューティングを使用している場合。
最初の例：の記憶形態7
オリジナルコード
（1）7が正であるので、フラグビットが0である
（2）残りの31ビットはデジタル部分を表す：000 0000 0000 0000 0,000,000,000,000,111は
そう元のコード7である：
0000 0000 0000 0000 0000 0000 0111 0000
補完
フォームがコンピュータ7に格納されているように、以下のように、元のコードのような補体と正数：
0000 0000 0000 0000 0,000,000,000,000,111
第二の例：ストレージフォーマット-7
元のコード
（1）-7負で、フラグビットが1
（2）を示し、残りの31パーツ番号：000 0000 0000 0000 0000 0000 0000 0111
ので、元のコード-7です：
1,000,000,000,000,000 0,000,000,000,000,111
補体
負補体フラグ、他のビットとビット単位に加えてあります。従って-7としてコンピュータに格納されている形態：
1,111,111,111,111,111 1,111,111,111,111,001
9 + 5計算
補数9のように表される：
0000 0000 0000 0000 0,000,000,000,001,001
5補数表現である：
0000 0000 0000 0000 0,000,000,000,000,101
2の補数の加算、および除去32以外の数：
0000 0000 0000 0000 0000 0000 0000 1110は、
結果14を得ます
9を計算- 5。
9の補数表現である：
0000 0000 0000 0000 0,000,000,000,001,001
-5補数として表現：
1,111,111,111,111,111 1,111,111,111,111,011
2の補数の加算、及び32以外の数を除去：
0000 0000 0000 0000 0,000,000,000,000,100
得る結果4
論理演算子
- （非オペレータ）
1.特徴：単項演算子、
2ルール：反対側の入力ビット値を生成する-入力0の場合、出力1;入力1の場合、入力0
3ケース：
INT〜A = 2;
のSystem.out。 println（A）; //結果は
4分析：
2の補数バイナリは次のように表現される：
00000000 00000000 0,000,000,000,000,010
操作：
〜00000000 00000000 0,000,000,000,000,010
------------------ ------------------------
1,111,111,111,111,111 1,111,111,111,111,101 //相補体に対応する小数：-3
アプリケーション
1〜N = - （N + 1）、例えば：1-3 = -4
2：ゲット整数nはバイナリ文字列の最後の1：-n＆N =〜（N-1）＆N
3：1バイナリ文字列、整数nの最後を除去する：N・（N-1）。
＆（And演算子）
1.特徴：バイナリ演算子、二つの操作バイナリデータ; 2つのバイナリ最下位ビットは、2つのビットの数だけがそれ以外の場合は0、1である場合にのみ正当化
2ケース：
INT 3＆A =。 2;
のSystem.out.println（A）; //結果は2つのである
。3.分析：
補数3を補完するように表現される：
00000000 00000000 0,000,000,000,000,011
：2の2の補数表現
00000000 00000000 0,000,000,000,000,010
操作：3＆2
00000000 00000000 00000000 00000011
＆00000000 00000000 0,000,000,000,000,010
------------------------------------------ -
00000000 00000000 0,000,000,000,000,010バイナリ2であります
アプリケーション
パリティの数nを決定します
"奇数" のn＆1 == 1：？ "でも"
なぜ判断と1つのパリティができますか？1 2にバイナリいわゆるはとても良い、完全であり、確実性も最も低いレベルは、0（ただ2上、右？）。同様に、最下位ビット奇数確か1.intタイプ1、最初の31ビットであります、0の両方の1および0または0 0結果は、次いで0最下位ビットの差が1で1であり、nはバイナリ最下位ビットが1（奇数）と1であり、結果が1であれば、抗結果であります0。
int a = 8;
if (a % 2 == 0) {
System.out.println("a是偶数");
} else {
System.out.println("a是奇数");
}
if ((a & 0x1) == 0) {
System.out.println("a是偶数");
} else {
System.out.println("a是奇数");
}
整数の2進数の1の数を求めます
アイデア：整数n 1及びAN AND演算、整数nは1であり、最下位ビット、結果が0そうでなければ、非ゼロです。
1は、左に1が、そうでなければ結果は0であり、動作およびN、低倍が1である場合、結果がゼロでないと進みます。
動作サイクル以上、非ゼロの数を記録することができます。
コードは以下の通りであります：
public class TestDemo {
public static void main(String[] args) {
int a = 7;
int retNum = times1(a);
System.out.println(retNum);
}
public static int times1(int n ){
int count = 0;
int flag = 1;
while(flag <= n){
if((n&flag) != 0)
count++;
flag = flag<<1;
}
return count;
}
}出力：
3
最適化された方法の
アイデア：
1.整数n、例えば10など、1010バイナリです。
2.保存10は、バイナリ9,9が1001であるとなり
減算操作にバイナリコンパレータ10と3 9、10バイナリ10と背面の最下位ビットのビット反転と等価であり、そして変わらない番号の前インチ
要約：次にマイナス1の整数であり、元の整数演算を行うには、整数0 1 1を右端であろう。そのような操作を行うことができる回数に1の数の整数のバイナリ表現。このような比較の数を減らすことができます。
public class TestDemo {
public static void main(String[] args) {
int a = 7;
int retNum = times2(a);
System.out.println(retNum);
}
public static int times2(int n){
int count = 0;
while(n!=0){
count++;
n = n&(n-1);
}
return count;
}
}
出力：
3
|（Or演算子）
1.特徴：バイナリ演算子、二つの動作のバイナリデータ、最も低い2つのバイナリビット整列し、両者のビット数があれば、それが1であるように、1、そうでなければ0
2ケース：
INT 3 A = |。 2;
のSystem.out.printlnは（A）; // 3であった。
3.分析：
補数3を補完するように表現される：
00000000 00000000 0,000,000,000,000,011
：2の2の補数表現
00000000 00000000 0,000,000,000,000,010
計算：3 | 2
00000000 00000000 00000011 00000000
| 00000000 00000000 00000000 00000010
------------------------------------------ -
小数3の相補体に対応する00000000 00000000 0,000,000,000,000,011
^（排他的論理和演算）
1.特徴：バイナリ演算子、二つの動作のバイナリデータ、最も低い2つのバイナリビット整列し、両者のビット数があれば、それが1であるように、1、そうでなければ0
2ケース：
INT 3 A = |。 2;
のSystem.out.printlnは（A）; // 3であった。
3.分析：
補数3を補完するように表現される：
00000000 00000000 0,000,000,000,000,011
：2の2の補数表現
00000000 00000000 0,000,000,000,000,010
計算：3 | 2
00000000 00000000 00000011 00000000
| 00000000 00000000 00000000 00000010
------------------------------------------ -
小数3の相補体に対応する00000000 00000000 0,000,000,000,000,011
^（排他的論理和演算）
1.特徴：;バイナリ演算子、二つの動作のバイナリデータの桁の二対が同時に1でない場合にのみ正当化2つのバイナリ最下位ビット、0と同じである
：2ケース
; INT = A ^ 2 3
システム.out.println（A）; //結果は1つのである
。3.分析：
補数3を補完するように表現される：
00000000 00000000 0,000,000,000,000,011
：2の2の補数表現
00000000 00000000 0,000,000,000,000,010
計算：^ 3 2
00000000 00000000 0,000,000,000,000,011
^ 00000000 00000000 0,000,000,000,000,010
-------------------------------------------
00000000 00000000小数の補数に対応0,000,000,000,000,001
アプリケーション
大文字に小文字、大文字に小文字（charArray [I] ^ = ASCIIコードのように32、大文字と小文字悪化32、従ってXOR演算子を使用して、または個別0によって、バイナリ形式最初の六つの異なる、または、元のビットは0〜1である場合、元のビット）が1 0であることに保持されている元の値の他のビットの元の文字：
public class TestDemo {
public static void main(String[] args) {
String tempString = "1a2b3E5F6P7p";
char [] charArray = tempString.toCharArray();
for(int i = 0; i < charArray.length; i++)
if(Character.isLetter(charArray[i])) charArray[i] ^= 32;
System.out.println(String.valueOf(charArray)); // result is 1A2B3e5f6p7P
}
}出力：
1A2B3e5f6p7P
一時変数スワップない二つの数字ありません
エンド・スワップのINT []配列では、このコードを見ていません。
public static int[] reverse(int[] nums){
int i = 0;
int j = nums.length-1;
while(j>i){
nums[i]= nums[i]^nums[j];
nums[j] = nums[j]^nums[i];
nums[i] = nums[i]^nums[j];
j--;
i++;
}
return nums;
}三回XORを使用して、そして何の一時的な変数は2つのデジタル切り替えを完了していない、どのようにそれを達成するには？
上記の計算は、主として式に従う：B ^（A ^ B）を=。
次のように私たちは、上記の式が導出されて行うことができます。
任意XOR結果自体の数と0定理A ^ B = B ^ Aが存在します。またはオペレータなしの異種配列は、B ^ A ^ B = B ^ B ^ Aは、結果が0 ^ Aです。
XOR演算が再び表に記載されています：
| 操作数1 |
0 |
0 |
1 |
1 |
| 操作数2 |
0 |
1 |
0 |
1 |
| ビットごとのXOR |
0 |
1 |
1 |
0 |
逆特性を有する排他的OR 0、および1 XORを保持する特性を有する、見つけることができます。これらの機能は、オペランドフェッチ使用して実行することができます。
0 ^ A、または0は、保持特性の排他的な使用を有し、その後、最終的な結果です。
実際には、数学の計算の法律を完全に遵守におけるXORアルゴリズムのJava：
①A ^ A = 0
②A ^ B = B ^ A
③A ^ B ^ C = A ^（B ^ C）=（A ^ B）^ C。
④D = A ^ B ^ Cが= D ^ B ^ Cを導入することができます。
⑤A ^ B ^ A = B。
<<（左シフト演算子）
0形式：M << N
1特徴：バイナリ演算子、結果のnビットのm桁の2進数の左シフト、同等の結果：M×（2のn乗）
2.ケース：
。INT 3 A = < <2;
;のSystem.out.printlnは、（A）//結果は12
：3分析
補数3を補完するように表現される：
00000000 00000000 0,000,000,000,000,011
計算：3 << 2
00000000 00000000 0,000,000,000,000,011
<< 2
------------------------------------- ------
00000000 00000000 0,000,000,000,001,100小数12の相補体に対応
アプリケーション
：M << Nのような結果を得るために使用することができます
System.out.println（ "2 ^ 3 =" +（1 << 3））; // 2 ^ 3 = 8
System.out.println（ "3 * 2 ^ 3 =" +（3 << 3））; // 3 * 2 ^ 3 = 24
結果はまだかなり右ではありませんか？彼は2 <<場合主張 - 1なぜ0.5に等しくない場合、以前に述べた、唯一のオペランドビット演算は、整数と文字です。表現できる最小の整数を求めている場合は、使用することができます
//記念
System.out.println（1 << 31）。
System.out.println（1 << -1）。
同じ結果が得られた31は、左側に見出すことができるとの結果が得られ-1位置が同じであり、同じように、左および30 -2を残しました。負のビットを動かし、それの右側に負の位置の絶対値と等しくありませんか？出力はそうではないものを見つけることができるようになります。Javaのint最大値は、31ビット、32ビット+符号ビットの合計で表すことができます。ここでは、このような変位法を持つことができます。
ルール1：左（右）32ビット乗算器の任意の数が数自体に等しいです。
規則2：nは正の数であればnが負の場合、Mの計算のシフト操作が<< nは、モバイルn個の％32のビットの実際の数は、その後のビットの数は、実際には（32 + N％32）に移動、右、共感。
2のべき乗で除算し、右に対応し、2のべき乗で残されます。
>>（右シフト演算子）
0形式：M >> N
1特徴：バイナリ演算子、M桁の二進nビット右に移動した結果、結果と同等である：M /（2のn乗）の結果は切り上げ
2ケース。
3 >> 2 = INT;
のSystem.out.println（A）; //結果が0である
3.分析：
：補体3は以下のように表現される補数
00000000 00000000 0,000,000,000,000,011
計算：3 >> 2
00000000 00000000 0,000,000,000,000,011
>> 2
------------------------------------- ------
00000000 00000000 00000000 00000000進0の相補体に対応する
4注：右に最後の二つの11移動、左側だけ0を構成して、その結果が0であります
>>>（符号なし右シフト演算子）
1.バイナリ演算子
2.特徴：それは関係なく、符号ビットの最上位ゼロであり、0で拡張されている
3ケース：
。INT 3 >>> A = 2;
のSystem.out.println（A）; //結果0
4.分析：
補数3を補完が発現されるような：
00000000 00000000 0,000,000,000,000,011
操作：
00000000 00000000 0,000,000,000,000,011
>>> 2
----------------------- -------------------
00000000 00000000 00000000 00000000
アプリケーションの絶対値
public class TestDemo {
public static void main(String[] args) {
int a = -3;
System.out.println(abs(a));
}
public static int abs(int val) {
// 看上去是够累的
return (((val & (~0 << 31)) >>> 31) == 1) ? ((~val) + 1) & (~(~0 << 31)) : val;
}
}出力：
3
絶対値
（^（>> 31）） - （>> 31）
ビット演算の絶対値を使用してのアイデアを整理するには：正の数である場合には、排他的論理和0の特性を維持する必要性と、変更されないまま、負の場合、反転すべてのソース1の補数その後、補体各-1、この場合に必要な、第1のソースを求め、その後反転する反転XOR特性を有します。
31右は、任意の正の数だけビット0に署名した後、最終的な結果は、符号ビット、0でのみ31後、31が空い31個の1つのシンボルのビットを埋める、右負オーバーフローを切り捨て、最終的な結果は-1。31右シフト演算は、任意のシンボルビットの整数であってもよいです。
上記式ので、包括的なステップを得ることができます。A >>正数、>> 31は、^ 0に等しい場合には、シンボルからなる31は、不変=;負の場合、>> 31は、A ^ -1反転毎に、-1に等しいです。 A。
ビット単位の追加
キャリービット和せずにプレスから入手可能なA ^ B。
利用可能なビットによってA＆Bは、所定の位置に生成されてもよいです。
キャリー（A＆B）によって得られた<< 1つの値。
次いで、その場でおよび^ B +（A・B）<< 1 +両側に対応し、次いで上記の3つのステップの加算演算に置換しながら、ビットキャリーを添加し、+添加とによって。キャリーは0であり、キャリー、すなわち、その場で、この時点で説明されていないと加算されるまで。
public class TestDemo {
public static void main(String[] args) {
int a = -3;
int b = 1;
System.out.println(add(a,b));
}
public static int add(int a,int b) {
int res=a;
int xor=a^b;//得到原位和
int forward=(a&b)<<1;//得到进位和
if(forward!=0){//若进位和不为0，则递归求原位和+进位和
res=add(xor, forward);
}else{
res=xor;//若进位和为0，则此时原位和为所求和
}
return res;
}
}出力：
-2
ビット算術減算
減算：AB
-b = +（ - B）〜（B-1）= - bが得られるAB = A +（ - B）= +（〜（B-1））。減算は、加算器に変換することができます。
public class TestDemo {
public static void main(String[] args) {
int a = -3;
int b = 1;
System.out.println(minus(a,b));
}
public static int add(int a,int b) {
int res=a;
int xor=a^b;//得到原位和
int forward=(a&b)<<1;//得到进位和
if(forward!=0){//若进位和不为0，则递归求原位和+进位和
res=add(xor, forward);
}else{
res=xor;//若进位和为0，则此时原位和为所求和
}
return res;
}
public static int minus(int a,int b) {
int B=~(b-1);
return add(a, B);
}
}出力：
-4
ビット乗算演算
乗算：* bの
バイナリ乗算は、まず、それがどのように行われるかを見てみましょう。
（1011 << 1、0010の当量を乗じた）
（1011 << 3、1000で乗算に相当）
ローからハイ乗算器に、そしてこの出会い1 1右I（私の出発の0点）の位置が、その後、私の左被乗数を置く第1の乗算器から：バイナリ乗算原則がある見ることができますtemp_iを取得するためのビット。乗数1を通過した後、被乗数左の値は、あなたに従って得られるまで、1 temp_iは、乗算結果を得るためにまで追加します。この原理によれば、コードを達成することができる：ここで重要である：私は現在のトラバーサル、被乗数ビットの現在のビットと乗数ビットを記録し、iは左側に追加されると、I ++はプロセスと同時に、あります0乗数権乗数1が終わるトラバースするまで、私は......乗数== 0説明との契約の下で、++。この時点で、あなたはに戻ってすることができます。
public class TestDemo {
public static void main(String[] args) {
int a = -3;
int b = 2;
System.out.println(multi(a,b));
}
public static int multi(int a,int b){
int i=0;
int res=0;
while(b!=0){//乘数为0则结束
//处理乘数当前位
if((b&1)==1){
res+=(a<<i);
b=b>>1;
++i;//i记录当前位是第几位
}else{
b=b>>1;
++i;
}
}
return res;
}
}出力：
-6
ビット単位の部門
除法：a/b
分裂を意味することはある：あなたの多くは、組成物Bを見つけることができますか。マイナスBの数は、減算の数は割り算の商をやっている見つけることができます。したがって、我々は分裂を得ることができることを実現します。
public class TestDemo {
public static void main(String[] args) {
int a = 6;
int b = 2;
System.out.println(sub(a,b));
}
public static int sub(int a,int b) {
int res=-1;
if(a<b){
return 0;
}else{
res=sub(minus(a, b), b)+1;
}
return res;
}
public static int minus(int a,int b) {
int B=~(b-1);
return add(a, B);
}
public static int add(int a,int b) {
int res=a;
int xor=a^b;//得到原位和
int forward=(a&b)<<1;//得到进位和
if(forward!=0){//若进位和不为0，则递归求原位和+进位和
res=add(xor, forward);
}else{
res=xor;//若进位和为0，则此时原位和为所求和
}
return res;
}
}出力：
3
数学的基礎
番号12について、次のとおりです1,2,3,4,6,12。6の合計
、この数は、他の多くの別の数で割り切れる数であることができ約数。2,3,4,6-が12で割り切れることができるような、12は、従って、ある2,3,4,6- 除数。また、要因として知られています。
約数の数を数えます
public class TestDemo {
public static void main(String[] args) {
int count = 0;
int n = 12;
for(int i = 1;i <= n;i++) {
if(n % i == 0)
count++;
}
System.out.println(count);
}
}出力：
6
素数は、 1に加えて、1より大きい自然数、およびなし因子自体として定義されます。
すべての素数の出力
public class TestDemo {
public static void main(String[] args) {
boolean flag = false;
for (int i = 2; i <= 10; i++) {
for (int j = 2; j * j < i; j++) {
if (i % j == 0) {
flag = true;
break;
}
}
if (flag == false) {
System.out.println(i);
}
flag = false;
}
}
}出力：
2
3
4
5
7
9
数係合手段は、分割（0を除く）全体に加えて、それ自体を除くだけでなく、他の数によって、自然数であることができます。コントラストは素数ですが、どちらも1つのもプライム一緒番号。最小の合成数は 4です。
アイデア（マイナス100-1000いわゆる合成数との間に素数の桁数）
出力コンポジット番号の数
public class TestDemo {
public static void main(String[] args) {
int a = 0;
int b = 0;
for (int i = 100; i <= 1000; i++) {
a++;
boolean d = true;
for (int j = i / 2 + 1; j > 1; j--) {
if (i % j == 0) {
d = false;
}
}
if (d == true) {
b++;
}
}
int c = a - b;
System.out.println(c);
}
}出力：
758