⑴ java 兩個整數相除,如果有餘數則取整數再加一，怎麼寫
public class Test {
public static void main(String[]args){
int a = 8;
int b = 3;
int c = 0;
if(a%b!=0){
c = a/b+1;
}
}
}
⑵ 【android】現在是三個editext，做除法，輸出結果，我這里的程序老錯，怎麼回事請高手指點。
很簡單，按照你的意思，button需要在oncreat方法中注冊，然後再按ctrl+1組合鍵提示導入onclicklisten就OK了
⑶ android 除法運算保留兩位小數 3/2=1.50;用Java 怎麼寫出來
BigDecimal bg = new BigDecimal(f);
double f1 = bg.setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue();
System.out.println(f1);
F是1.5 F1是1.50
⑷ 10-27 13:10:06.424: ERROR/AndroidRuntime(1072): java.lang.NumberFormatException: unable to parse '3
我也是遇到類似的問題了，等待解決：System.out(821): java.lang.NumberFormatException: unable to parse '' as integer
⑸ android完成任意兩個數之餘除數不能為0的編程代碼
Android是一種基於Linux的自由及開放源代碼的操作系統，主要使用於移動設備，如智能手機和平板電腦，由Google公司和開放手機聯盟領導及開發。Android操作系統最初由Andy Rubin開發，主要支持手機。2005年8月由Google收購注資。2007年11月，Google與84家硬體製造商、軟體開發商及電信營運商組建開放手機聯盟共同研發改良Android系統。隨後Google以Apache開源許可證的授權方式，發布了Android的源代碼。第一部Android智能手機發布於2008年10月。Android逐漸擴展到平板電腦及其他領域上，如電視、數碼相機、游戲機等。
⑹ 用二進制除法10110110011000除1101
fragment是3.0以後的東西，為了在低版本中使用fragment就要用到android-support-v4.jar兼容包,而fragmentActivity就是這個兼容包裡面的，它提供了操作fragment的一些方法，其功能跟3.0及以後的版本的Activity的功能一樣。
下面是API中的原話：
FragmentActivity is a special activity provided in the Support Library to handle fragments on system versions older than API level 11. If the lowest system version you support is API level 11 or higher, then you can use a regular Activity.
1、fragmentactivity 繼承自activity，用來解決android3.0 之前沒有fragment的api，所以在使用的時候需要導入support包，同時繼承fragmentActivity，這樣在activity中就能嵌入fragment來實現你想要的布局效果。
2、當然3.0之後你就可以直接繼承自Activity，並且在其中嵌入使用fragment了。
3、獲得Manager的方式也不同
3.0以下：getSupportFragmentManager()
3.0以上：getFragmentManager()
⑺ android寫一個演算法求12和8的最大公約數
classex1
{
intgys1(intm,intn)//循環實現
{
intk,y;
if(m<n)
{
k=m;
m=n;
n=k;
}
while(m%n!=0)
{
y=m%n;
m=n;
n=y;
}
returnn;
}
intgys2(intm,intn)//遞歸實現
{
intk,y;
if(m<n)
{
k=m;
m=n;
n=k;
}
y=m%n;
if(y==0)
{
returnn;
}
else
{
m=n;
n=y;
returngys2(m,n);
}
}
publicstaticvoidmain(String[]args)
{
ex1e1=newex1();
System.out.println(e1.gys1(12,8));
ex1e2=newex1();
System.out.println(e1.gys2(12,8));
}
}
⑻ 如何編寫高效android代碼
現代的手持設備，與其說是電話，更像一台拿在手中的電腦。但是，即使是「最快」的手持設備，其性能也趕不上一台普通的台式電腦。
這就是為什麼我們在書寫Android應用程序的時候要格外關注效率。這些設備並沒有那麼快，並且受電池電量的制約。這意味著，設備沒有更多的能力，我們必須把程序寫的盡量有效。
本文討論了很多能讓開發者使他們的程序運行更有效的方法，遵照這些方法，你可以使你的程序發揮最大的效力。
簡介
對於佔用資源的系統，有兩條基本原則：
不要做不必要的事
不要分配不必要的內存
所有下面的內容都遵照這兩個原則。
有些人可能馬上會跳出來，把本節的大部分內容歸於「草率的優化」（xing:參見[The Root of All Evil]），不可否認微優化（micro-optimization。xing:代碼優化，相對於結構優化）的確會帶來很多問題，諸如無法使用更有效的數據結構和演算法。但是在手持設備上，你別無選擇。假如你認為Android虛擬機的性能與台式機相當，你的程序很有可能一開始就佔用了系統的全部內存（xing:內存很小），這會讓你的程序慢得像蝸牛一樣，更遑論做其他的操作了。
Android的成功依賴於你的程序提供的用戶體驗。而這種用戶體驗，部分依賴於你的程序是響應快速而靈活的，還是響應緩慢而僵化的。因為所有的程序都運行在同一個設備之上，都在一起，這就如果在同一條路上行駛的汽車。而這篇文檔就相當於你在取得駕照之前必須要學習的交通規則。如果大家都按照這些規則去做，駕駛就會很順暢，但是如果你不這樣做，你可能會車毀人亡。這就是為什麼這些原則十分重要。
當我們開門見山、直擊主題之前，還必須要提醒大家一點：不管VM是否支持實時（JIT）編譯器（xing:它允許實時地將Java解釋型程序自動編譯成本機機器語言，以使程序執行的速度更快。有些JVM包含JIT編譯器。），下面提到的這些原則都是成立的。假如我們有目標完全相同的兩個方法，在解釋執行時foo()比bar()快，那麼編譯之後，foo()依然會比bar()快。所以不要寄希望於編譯器可以拯救你的程序。
避免建立對象
世界上沒有免費的對象。雖然GC為每個線程都建立了臨時對象池，可以使創建對象的代價變得小一些，但是分配內存永遠都比不分配內存的代價大。
如果你在用戶界面循環中分配對象內存，就會引發周期性的垃圾回收，用戶就會覺得界面像打嗝一樣一頓一頓的。
所以，除非必要，應盡量避免盡力對象的實例。下面的例子將幫助你理解這條原則：
當你從用戶輸入的數據中截取一段字元串時，盡量使用substring函數取得原始數據的一個子串，而不是為子串另外建立一份拷貝。這樣你就有一個新的String對象，它與原始數據共享一個char數組。
如果你有一個函數返回一個String對象，而你確切的知道這個字元串會被附加到一個StringBuffer，那麼，請改變這個函數的參數和實現方式，直接把結果附加到StringBuffer中，而不要再建立一個短命的臨時對象。
一個更極端的例子是，把多維數組分成多個一維數組。
int數組比Integer數組好，這也概括了一個基本事實，兩個平行的int數組比(int,int)對象數組性能要好很多。同理，這試用於所有基本類型的組合。
如果你想用一種容器存儲(Foo,Bar)元組，嘗試使用兩個單獨的Foo[]數組和Bar[]數組，一定比(Foo,Bar)數組效率更高。（也有例外的情況，就是當你建立一個API，讓別人調用它的時候。這時候你要注重對API借口的設計而犧牲一點兒速度。當然在API的內部，你仍要盡可能的提高代碼的效率）
總體來說，就是避免創建短命的臨時對象。減少對象的創建就能減少垃圾收集，進而減少對用戶體驗的影響。
使用本地方法
當你在處理字串的時候，不要吝惜使用String.indexOf(), String.lastIndexOf()等特殊實現的方法（specialty methods）。這些方法都是使用C/C++實現的，比起Java循環快10到100倍。
使用實類比介面好
假設你有一個HashMap對象，你可以將它聲明為HashMap或者Map:
Map myMap1 = new HashMap();HashMap myMap2 = new HashMap();
哪個更好呢？
按照傳統的觀點Map會更好些，因為這樣你可以改變他的具體實現類，只要這個類繼承自Map介面。傳統的觀點對於傳統的程序是正確的，但是它並不適合嵌入式系統。調用一個介面的引用會比調用實體類的引用多花費一倍的時間。
如果HashMap完全適合你的程序，那麼使用Map就沒有什麼價值。如果有些地方你不能確定，先避免使用Map，剩下的交給IDE提供的重構功能好了。(當然公共API是一個例外：一個好的API常常會犧牲一些性能）
用靜態方法比虛方法好
如果你不需要訪問一個對象的成員變數，那麼請把方法聲明成static。虛方法執行的更快，因為它可以被直接調用而不需要一個虛函數表。另外你也可以通過聲明體現出這個函數的調用不會改變對象的狀態。
不用getter和setter
在很多本地語言如C++中，都會使用getter（比如：i = getCount()）來避免直接訪問成員變數（i = mCount）。在C++中這是一個非常好的習慣，因為編譯器能夠內聯訪問，如果你需要約束或調試變數，你可以在任何時候添加代碼。
在Android上，這就不是個好主意了。虛方法的開銷比直接訪問成員變數大得多。在通用的介面定義中，可以依照OO的方式定義getters和setters，但是在一般的類中，你應該直接訪問變數。
將成員變數緩存到本地
訪問成員變數比訪問本地變數慢得多，下面一段代碼：
for (int i = 0; i < this.mCount; i++)mpItem(this.mItems[i]);
再好改成這樣：
int count = this.mCount;Item[] items = this.mItems; for (int i = 0; i < count; i++)mpItems(items[i]);
（使用"this"是為了表明這些是成員變數）
另一個相似的原則是：永遠不要在for的第二個條件中調用任何方法。如下面方法所示，在每次循環的時候都會調用getCount()方法，這樣做比你在一個int先把結果保存起來開銷大很多。
for (int i = 0; i < this.getCount(); i++)mpItems(this.getItem(i));
同樣如果你要多次訪問一個變數，也最好先為它建立一個本地變數，例如：
protected void drawHorizontalScrollBar(Canvas canvas, int width, int height) {if (isHorizontalScrollBarEnabled()) {int size = mScrollBar.getSize(false);if (size <= 0) {size = mScrollBarSize;}mScrollBar.setBounds(0, height - size, width, height);mScrollBar.setParams(computeHorizontalScrollRange(),computeHorizontalScrollOffset(),computeHorizontalScrollExtent(), false);mScrollBar.draw(canvas);}}
這里有4次訪問成員變數mScrollBar，如果將它緩存到本地，4次成員變數訪問就會變成4次效率更高的棧變數訪問。
另外就是方法的參數與本地變數的效率相同。
使用常量
讓我們來看看這兩段在類前面的聲明：
static int intVal = 42;static String strVal = "Hello, world!";
必以其會生成一個叫做<clinit>的初始化類的方法，當類第一次被使用的時候這個方法會被執行。方法會將42賦給intVal，然後把一個指向類中常量表的引用賦給strVal。當以後要用到這些值的時候，會在成員變數表中查找到他們。
下面我們做些改進，使用「final"關鍵字：
static final int intVal = 42;static final String strVal = "Hello, world!";
現在，類不再需要<clinit>方法，因為在成員變數初始化的時候，會將常量直接保存到類文件中。用到intVal的代碼被直接替換成42，而使用strVal的會指向一個字元串常量，而不是使用成員變數。
將一個方法或類聲明為"final"不會帶來性能的提升，但是會幫助編譯器優化代碼。舉例說，如果編譯器知道一個"getter"方法不會被重載，那麼編譯器會對其採用內聯調用。
你也可以將本地變數聲明為"final"，同樣，這也不會帶來性能的提升。使用"final"只能使本地變數看起來更清晰些（但是也有些時候這是必須的，比如在使用匿名內部類的時候）（xing:原文是 or you have to, e.g. for use in an anonymous inner class）
謹慎使用foreach
foreach可以用在實現了Iterable介面的集合類型上。foreach會給這些對象分配一個iterator，然後調用 hasNext()和next()方法。你最好使用foreach處理ArrayList對象，但是對其他集合對象，foreach相當於使用 iterator。
下面展示了foreach一種可接受的用法：
public class Foo {int mSplat;static Foo mArray[] = new Foo[27]; public static void zero() {int sum = 0;for (int i = 0; i < mArray.length; i++) {sum += mArray[i].mSplat;}} public static void one() {int sum = 0;Foo[] localArray = mArray;int len = localArray.length;for (int i = 0; i < len; i++) {sum += localArray[i].mSplat;}} public static void two() {int sum = 0;for (Foo a: mArray) {sum += a.mSplat;}}}
在zero()中，每次循環都會訪問兩次靜態成員變數，取得一次數組的長度。
retrieves the static field twice and gets the array length once for every iteration through the loop.
在one()中，將所有成員變數存儲到本地變數。 pulls everything out into local variables, avoiding the lookups.
two()使用了在java1.5中引入的foreach語法。編譯器會將對數組的引用和數組的長度保存到本地變數中，這對訪問數組元素非常好。但是編譯器還會在每次循環中產生一個額外的對本地變數的存儲操作（對變數a的存取）這樣會比one()多出4個位元組，速度要稍微慢一些。
綜上所述：foreach語法在運用於array時性能很好，但是運用於其他集合對象時要小心，因為它會產生額外的對象。
避免使用枚舉
枚舉變數非常方便，但不幸的是它會犧牲執行的速度和並大幅增加文件體積。例如：
public class Foo {public enum Shrubbery { GROUND, CRAWLING, HANGING }}
會產生一個900位元組的.class文件(Foo$Shubbery.class)。在它被首次調用時，這個類會調用初始化方法來准備每個枚舉變數。每個枚舉項都會被聲明成一個靜態變數，並被賦值。然後將這些靜態變數放在一個名為"$VALUES"的靜態數組變數中。而這么一大堆代碼，僅僅是為了使用三個整數。
這樣:
Shrubbery shrub = Shrubbery.GROUND;會引起一個對靜態變數的引用，如果這個靜態變數是final int，那麼編譯器會直接內聯這個常數。
一方面說，使用枚舉變數可以讓你的API更出色，並能提供編譯時的檢查。所以在通常的時候你毫無疑問應該為公共API選擇枚舉變數。但是當性能方面有所限制的時候，你就應該避免這種做法了。
有些情況下，使用ordinal()方法獲取枚舉變數的整數值會更好一些，舉例來說，將：
for (int n = 0; n < list.size(); n++) {if (list.items[n].e == MyEnum.VAL_X)// do stuff 1else if (list.items[n].e == MyEnum.VAL_Y)// do stuff 2}
替換為:
int valX = MyEnum.VAL_X.ordinal();int valY = MyEnum.VAL_Y.ordinal();int count = list.size();MyItem items = list.items(); for (int n = 0; n < count; n++){int valItem = items[n].e.ordinal(); if (valItem == valX)// do stuff 1else if (valItem == valY)// do stuff 2}
會使性能得到一些改善，但這並不是最終的解決之道。
將與內部類一同使用的變數聲明在包范圍內
請看下面的類定義：
public class Foo {private int mValue; public void run() {Inner in = new Inner();mValue = 27;in.stuff();} private void doStuff(int value) {System.out.println("Value is " + value);} private class Inner {void stuff() {Foo.this.doStuff(Foo.this.mValue);}}}
這其中的關鍵是，我們定義了一個內部類(Foo$Inner)，它需要訪問外部類的私有域變數和函數。這是合法的，並且會列印出我們希望的結果"Value is 27"。
問題是在技術上來講（在幕後）Foo$Inner是一個完全獨立的類，它要直接訪問Foo的私有成員是非法的。要跨越這個鴻溝，編譯器需要生成一組方法：
static int Foo.access$100(Foo foo) {return foo.mValue;}static void Foo.access$200(Foo foo, int value) {foo.doStuff(value);}
內部類在每次訪問"mValue"和"doStuff"方法時，都會調用這些靜態方法。就是說，上面的代碼說明了一個問題，你是在通過介面方法訪問這些成員變數和函數而不是直接調用它們。在前面我們已經說過，使用介面方法（getter、setter）比直接訪問速度要慢。所以這個例子就是在特定語法下面產生的一個「隱性的」性能障礙。
通過將內部類訪問的變數和函數聲明由私有范圍改為包范圍，我們可以避免這個問題。這樣做可以讓代碼運行更快，並且避免產生額外的靜態方法。（遺憾的是，這些域和方法可以被同一個包內的其他類直接訪問，這與經典的OO原則相違背。因此當你設計公共API的時候應該謹慎使用這條優化原則）
避免使用浮點數
在奔騰CPU出現之前，游戲設計者做得最多的就是整數運算。隨著奔騰的到來，浮點運算處理器成為了CPU內置的特性，浮點和整數配合使用，能夠讓你的游戲運行得更順暢。通常在桌面電腦上，你可以隨意的使用浮點運算。
但是非常遺憾，嵌入式處理器通常沒有支持浮點運算的硬體，所有對"float"和"double"的運算都是通過軟體實現的。一些基本的浮點運算，甚至需要毫秒級的時間才能完成。
甚至是整數，一些晶元有對乘法的硬體支持而缺少對除法的支持。這種情況下，整數的除法和取模運算也是有軟體來完成的。所以當你在使用哈希表或者做大量數學運算時一定要小心謹慎。
⑼ java如何判斷一個數是否能被整除
1、java可以取余運算，來判斷一個數能否被整除。如果n除以m的余數為零,我們說n可以被m整除。
2、判斷整除，可以使用C語言中的求余操作，符號為%。m%n結果為m除以n所得余數。根據整除規則，如果m除以n余數為0，則m可以被n整除。
3、Java是一種可以撰寫跨平台應用軟體的面向對象的程序設計語言。Java 技術具有卓越的通用性、高效性、平台移植性和安全性，廣泛應用於PC、數據中心、游戲控制台、科學超級計算機、行動電話和互聯網，同時擁有全球最大的開發者專業社群。
4、Object類中的getClass方法返回Class類型的一個實例，程序啟動時包含在main方法的類會被載入，虛擬機要載入他需要的所有類，每一個載入的類都要載入它需要的類。
⑽ android 除法跟計算器算得不一樣
是不是進制（模式）選的不對啊！