来源：蜘蛛抓取(WebSpider)
时间：2015-08-08 16:39
标签：
java编程
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
您的访问请求被拒绝 403 Forbidden - ITeye技术社区
您的访问请求被拒绝
亲爱的会员，您的IP地址所在网段被ITeye拒绝服务，这可能是以下两种情况导致：
一、您所在的网段内有网络爬虫大量抓取ITeye网页，为保证其他人流畅的访问ITeye，该网段被ITeye拒绝
二、您通过某个代理服务器访问ITeye网站，该代理服务器被网络爬虫利用，大量抓取ITeye网页
请您点击按钮解除封锁&java编程错误集锦
错误1（jdbc）：java.sql.SQLException: Before start of result set at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1075) at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:989) at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:984) at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:929) at com.mysql.jdbc.ResultSetImpl.checkRowPos(ResultSetImpl.java:841)at com.mysql.jdbc.ResultSetImpl.getInt(ResultSetImpl.java:2672)解决方案：
得到rs后 先要rs.next()
如果直接rs.getXXX的话 就会出现这个问题了（结果来自互联网）
最新教程周点击榜
微信扫一扫Java编程提高性能时需注意的地方 - 文章 - 伯乐在线
& Java编程提高性能时需注意的地方
& 来源： &&&&
最近的机器内存又爆满了，除了新增机器内存外，还应该好好review一下我们的代码，有很多代码编写过于随意化，这些不好的习惯或对程序语言的不了解是应该好好打压打压了。
下面是参考网络资源和总结一些在java编程中尽可能做到的一些地方
1.尽量在合适的场合使用单例
使用单例可以减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面
第一，控制资源的使用，通过线程同步来控制资源的并发访问
第二，控制实例的产生，以达到节约资源的目的
第三，控制数据共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信
2.尽量避免随意使用静态变量
要知道，当某个对象被定义为stataic变量所引用，那么gc通常是不会回收这个对象所占有的内存，如
public class A{
static B b = new B();
public class A{ static B b = new B(); }
此时静态变量b的生命周期与A类同步，如果A类不会卸载，那么b对象会常驻内存，直到程序终止。
3.尽量避免过多过常的创建java对象
尽量避免在经常调用的方法，循环中new对象，由于系统不仅要花费时间来创建对象，而且还要花时间对这些对象进行垃圾回收和处理，在我们可以控制的范围内，最大限度的重用对象，最好能用基本的数据类型或数组来替代对象。
4.尽量使用final修饰符
带 有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指 定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。java编译器会寻找机会内联 (inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%。
5.尽量使用局部变量
调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中，速度较快。其他变量，如静态变量，实例变量等，都在堆(Heap)中创建，速度较慢。
6.尽量处理好包装类型和基本类型两者的使用场所
虽然包装类型和基本类型在使用过程中是可以相互转换，但它们两者所产生的内存区域是完全不同的，基本类型数据产生和处理都在栈中处理，包装类型是对象，是在堆中产生实例。
在集合类对象，有对象方面需要的处理适用包装类型，其他的处理提倡使用基本类型。
7.慎用synchronized，尽量减小synchronize的方法
都 知道，实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。synchronize方法被调用时，直接会把当前对象锁 了，在方法执行完之前其他线程无法调用当前对象的其他方法。所以synchronize的方法尽量小，并且应尽量使用方法同步代替代码块同步。
8.尽量使用StringBuilder和StringBuffer进行字符串连接
这个就不多讲了
9.尽量不要使用finalize方法
实际上，将资源清理放在finalize方法中完成是非常不好的选择，由于GC的工作量很大，尤其是回收Young代内存时，大都会引起应用程序暂停，所以再选择使用finalize方法进行资源清理，会导致GC负担更大，程序运行效率更差。
10.尽量使用基本数据类型代替对象
String str = "hello";
String str = "hello";
上面这种方式会创建一个“hello”字符串，而且JVM的字符缓存池还会缓存这个字符串；
String str = new String("hello");
String str = new String("hello");
此时程序除创建字符串外，str所引用的String对象底层还包含一个char[]数组，这个char[]数组依次存放了h,e,l,l,o
11.单线程应尽量使用HashMap, ArrayList
HashTable,Vector等使用了同步机制，降低了性能。
12.尽量合理的创建HashMap
当你要创建一个比较大的hashMap时，充分利用另一个构造函数
public HashMap(int initialCapacity, float loadFactor)
public HashMap(int initialCapacity, float loadFactor)
避 免HashMap多次进行了hash重构,扩容是一件很耗费性能的事，在默认中initialCapacity只有16，而loadFactor是 0.75，需要多大的容量，你最好能准确的估计你所需要的最佳大小，同样的Hashtable，Vectors也是一样的道理。
13.尽量减少对变量的重复计算
for(int i=0;i&list.size();i++)
for(int i=0;i&list.size();i++)
for(int i=0,len=list.size();i&i++)
for(int i=0,len=list.size();i&len;i++)
并且在循环中应该避免使用复杂的表达式，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。
14.尽量避免不必要的创建
A a = new A();
if(i==1){list.add(a);}
A a = new A(); if(i==1){list.add(a);}
A a = new A();
list.add(a);}
if(i==1){ A a = new A(); list.add(a);}
15.尽量在finally块中释放资源
程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。
16.尽量使用移位来代替’a/b’的操作
“/”是一个代价很高的操作，使用移位的操作将会更快和更有效
int num = a / 4;
int num = a / 8;
int num = a / 4; int num = a / 8;
int num = a && 2;
int num = a && 3;
int num = a && 2; int num = a && 3;
但注意的是使用移位应添加注释，因为移位操作不直观，比较难理解
17.尽量使用移位来代替’a*b’的操作
同样的，对于’*’操作，使用移位的操作将会更快和更有效
int num = a * 4;
int num = a * 8;
int num = a * 4; int num = a * 8;
int num = a && 2;
int num = a && 3;
int num = a && 2; int num = a && 3;
18.尽量确定StringBuffer的容量
StringBuffer 的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再 丢弃旧的数组。在大多数情况下，你可以在创建 StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。
如：StringBuffer buffer = new StringBuffer(1000);
19.尽量早释放无用对象的引用
大部分时，方法局部引用变量所引用的对象 会随着方法结束而变成垃圾，因此，大部分时候程序无需将局部，引用变量显式设为null。
Public void test(){
Object obj = new Object();
Public void test(){ Object obj = new Object(); …… Obj=null; }
上面这个就没必要了，随着方法test()的执行完成，程序中obj引用变量的作用域就结束了。但是如果是改成下面：
Public void test(){
Object obj = new Object();
//执行耗时，耗内存操作；或调用耗时，耗内存的方法
Public void test(){ Object obj = new Object(); …… Obj=null;//执行耗时，耗内存操作；或调用耗时，耗内存的方法 …… }
这时候就有必要将obj赋值为null，可以尽早的释放对Object对象的引用。
20.尽量避免使用二维数组
二维数据占用的内存空间比一维数组多得多，大概10倍以上。
21.尽量避免使用split
除 非是必须的，否则应该避免使用split，split由于支持正则表达式，所以效率比较低，如果是频繁的几十，几百万的调用将会耗费大量资源，如果确实需 要频繁的调用split，可以考虑使用apache的StringUtils.split(string,char)，频繁split的可以缓存结果。
22.ArrayList & LinkedList
一 个是线性表，一个是链表，一句话，随机查询尽量使用ArrayList，ArrayList优于LinkedList，LinkedList还要移动指 针，添加删除的操作LinkedList优于ArrayList，ArrayList还要移动数据，不过这是理论性分析，事实未必如此，重要的是理解好2 者得数据结构，对症下药。
23.尽量使用System.arraycopy ()代替通过来循环复制数组
System.arraycopy() 要比通过循环来复制数组快的多
24.尽量缓存经常使用的对象
尽可能将经常使用的对象进行缓存，可以使用数组，或HashMap的容器来进行缓存，但这种方式可能导致系统占用过多的缓存，性能下降，推荐可以使用一些第三方的开源工具，如EhCache，Oscache进行缓存，他们基本都实现了FIFO/FLU等缓存算法。
25.尽量避免非常大的内存分配
有时候问题不是由当时的堆状态造成的，而是因为分配失败造成的。分配的内存块都必须是连续的，而随着堆越来越满，找到较大的连续块越来越困难。
26.慎用异常
当 创建一个异常时，需要收集一个栈跟踪(stack track)，这个栈跟踪用于描述异常是在何处创建的。构建这些栈跟踪时需要为运行时栈做一份快照，正是这一部分开销很大。当需要创建一个 Exception 时，JVM 不得不说：先别动，我想就您现在的样子存一份快照，所以暂时停止入栈和出栈操作。栈跟踪不只包含运行时栈中的一两个元素，而是包含这个栈中的每一个元素。
如 果您创建一个 Exception ，就得付出代价。好在捕获异常开销不大，因此可以使用 trycatch 将核心内容包起来。从技术上讲，您甚至可以随意地抛出异常，而不用花费很大的代价。招致性能损失的并不是 throw 操作——尽管在没有预先创建异常的情况下就抛出异常是有点不寻常。真正要花代价的是创建异常。幸运的是，好的编程习惯已教会我们，不应该不管三七二十一就 抛出异常。异常是为异常的情况而设计的，使用时也应该牢记这一原则。
文章主要是为了抛砖引玉，希望有更多牛人的指点。
===================================================
7.慎用synchronized，尽量减小synchronize的方法
re：同意，不过文中有个地方说错了，使用synchronized关键字并不一定都是锁定当前对象的，要看具体的锁是什么。如果是在方法上加的synchronized，则是以对象本身为锁的，如果是静态方法则锁的粒度是类。
9.尽量不要使用finalize方法
re：同意，其实不推荐用finalize方法的根本原因在于，JVM的规范并不保证何时执行该方法，所以用这个方法来释放资源很不合适，有可能造成长时间资源得不到释放。
16.尽量使用移位来代替’a/b’的操作；17.尽量使用移位来代替’a*b’的操作
re：个人不太同意这两条。这样做确实有更好的性能，但是却牺牲了可读性。这两个操作符对很多程序员来说并不直观。我认为在如今硬件价格不那么昂贵的情况下，略微牺牲一些性能，换来更好的可读性和可维护性是好的选择。
===================================================
19.尽量早释放无用对象的引用大部分时，方法局部引用变量所引用的对象 会随着方法结束而变成垃圾，因此，大部分时候程序无需将局部，引用变量显式设为null。
Public void test(){
Object obj = new Object();
上面这个就没必要了，随着方法test()的执行完成，程序中obj引用变量的作用域就结束了。但是如果是改成下面：
Public void test(){
Object obj = new Object();
//执行耗时，耗内存操作；或调用耗时，耗内存的方法
12345678910111213
Public void test(){ Object obj = new Object(); …… Obj=null; } 上面这个就没必要了，随着方法test()的执行完成，程序中obj引用变量的作用域就结束了。但是如果是改成下面： Public void test(){ Object obj = new Object(); …… Obj=null; //执行耗时，耗内存操作；或调用耗时，耗内存的方法 …… }
如果Object obj = new Object(); 如果这对象并不是大对象，这有必要吗？Obj=只是告诉jvm这个对象已经成为垃圾，至于什么时候回收，还不能确定！ 这可读性也不好！
可能感兴趣的话题
总体上感觉写的不错。最后xuanyuan 的建议也不错。不过在注释允许的情况下，还是要用移位操作的。另外，synchronized关键字，并不是你用了，jvm就会给加锁的。现在的jvm可以判断到底有没有必要加锁。如果没有必要，就会把锁给优化掉了。跟没加一样。
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线内容团队正试图以我们微薄的力量，把优秀的原创文章和译文分享给读者，为“快餐”添加一些“营养”元素。
新浪微博：
推荐微信号
（加好友请注明来意）
– 好的话题、有启发的回复、值得信赖的圈子
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选文章
– UI,网页，交互和用户体验
– 专注iOS技术分享
– 专注Android技术分享
– JavaScript, HTML5, CSS
– 专注Java技术分享
– 专注Python技术分享
& 2016 伯乐在线华为Java机考题 - 编程当前位置:& &&&华为Java机考题华为Java机考题&&网友分享于：&&浏览：0次华为Java机试题1.程序实现目标：&输入一个字符串，将其各个字符对应的ASCII值加5后，输出结果。
&&& 程序要求：该字符串只包含小写字母，若其值加5后的字符值大于'z',将其转换成从a开始的字符。
package com.
* @author &span style=&font-family:宋体;&&xcbeyond&/span&
* 下午10:37:43
* 1.程序实现目标： 输入一个字符串，将其各个字符对应的ASCII值加5后，输出结果。
* 程序要求：该字符串只包含小写字母，若其值加5后的字符值大于'z',将其转换成从a开始的字符。
public class StringParseASCII {
public static void main(String[] args) {
System.out.print(stringParseASCII(&abx&));
public static String stringParseASCII(String str){
StringBuffer result = new StringBuffer();
for(int i = 0;i&str.length();i++){
tmp = (char)(str.charAt(i)+5);
if(tmp & 'z') {
result.append('a');
result.append(tmp);
return result.toString();
2.程序实现目标：求一个整型数组中元素的平均值，并统计其中大于和小于此平均值的元素的个数。
& 程序要求：输入：整型数组中的元素个数及各个元素。
&&&&&&&& & & & & & & 输出：整型数组中元素的平均值，大于和小于此平均值的元素的个数。
package com.
import java.util.A
* @author xcbeyond
* 下午11:06:29
*2.程序实现目标：求一个整型数组中元素的平均值，并统计其中大于和小于此平均值的元素的个数。
*程序要求：
* 输入：整型数组中的元素个数及各个元素。
* 输出：整型数组中元素的平均值，大于和小于此平均值的元素的个数。
public class CountAvg {
public static void main(String[] args) {
int[] array = {1,23,4,13,6};
System.out.println(Arrays.toString(array)+&的平均值：&+avg(array)+&\n& +
&大于和小于平均值元素的个数分别为：&+Arrays.toString(countAvg(array)));
public static int[] countAvg(int[] array) {
int gt = 0; //grater than
int lt = 0; //less than
int[] result = {0,0};
int average = avg(array);
for(int i = 0;i&array.i++) {
if(array[i]&average) {
}else if(array[i]&average) {
result[0] =
result[1] =
* @param array
public static int avg(int[] array) {
int average = 0;
int sum = 0;
for(int i = 0 ;i&array.i++) {
sum += array[i];
average = sum/array.
3、手动输入一个存储整数的数组，要求输出数组里面的2个最大值。
&& 实例：&
&&&&&&&&&&&& 输入：1,2,5,9,84,3,2
&&&&&&&&&&&& 输出：84,9
package com.
import java.util.A
* @author &span style=&font-family:C&&xcbeyond&/span&
* 下午11:35:13
*3、手动输入一个存储整数的数组，要求输出数组里面的2个最大值。
输入：1,2,5,9,84,3,2
输出：84,9
public class FindMaxTwoNum {
public static void main(String[] args) {
int[] array = {1,2,5,9,84,3,2};
System.out.println(&数组&+Arrays.toString(array)+&里面最大的2个数为：&);
findMaxTwoNum(array);
&span style=&font-family:C&&
//方法二：
&/span& }
public static void findMaxTwoNum(int[] array) {
int[] result = {0,0};
for(int i = 0 ;i&array.i++) {
for(int j = 0;j&array.length-i-1;j++) {
if(array[j]&array[j+1]) {
tmp = array[j];
array[j] = array[j+1];
array[j+1] =
System.out.println(array[0]+&、&+array[1]);
4、回文数字判断。
题目描述：
&&& 有这样一类数字，他们顺着看和倒着看是相同的数，例如：121,656,2332等，这样的数字就称为：回文数字。编写一个函数，判断某数字是否是回文数字。
&&& 要求实现方法：
public&String&isPalindrome(String&strIn);
【输入】strIn:&整数，以字符串表示；
【返回】true:&是回文数字；
&&&&&&&&&&&&& false:&不是回文数字；
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
package com.
import java.util.S
* @author xcbeyond
* 下午03:46:56
*4、回文数字判断。
*题目描述：
* 有这样一类数字，他们顺着看和倒着看是相同的数，例如：121,656,2332等，这样的数字就称为：
* 回文数字。编写一个函数，判断某数字是否是回文数字。
public class IsPalindrome {
public static void main(String[] args) {
System.out.print(&请输入一个回文数字：&);
Scanner console
= new Scanner(System.in);
String numStr = console.nextLine();
if(isPalindrome(numStr)) {
System.out.println(numStr+&是回文数字！&);
System.out.println(numStr+&不是回文数字！&);
public static boolean isPalindrome(String str){
boolean result =
for(int i = 0 ;i&str.length()/2-1;i++) {
if(str.charAt(i) == str.charAt(str.length()-1-i)) {
5、要求：随机打印50个随机（4-10长度）的字符串，要求字符串包含的范围是所有的英文字母包含大小写和数字，按照编码顺序排序，每行打印4个，要求首字符对齐
&package com.
import java.util.HashS
import java.util.S
* @author xcbeyond
* 下午04:05:42
*5、要求：随机打印50个随机（4-10长度）的字符串，要求字符串包含的范围是
所有的英文字母包含大小写和数字，按照编码顺序排序，每行打印4个，要求首字符对齐
public class RandomStr {
public static void main(String[] args) {
Set&String& setStr = new HashSet&String&();
for(int i = 0 ;i&50;i++) {
setStr.add(randomStr(5));
int count = 1;
for(String i:setStr){
System.out.print(i+& &);
if(count%4 == 0) {
System.out.println();
* @param strLen:随机字符串的长度
public static String randomStr(int strLen) {
char[] str = new char[strLen];
int i = 0;
while(i&strLen) {
int f = (int)Math.random()*3;
if(f == 0) {
str[i] = (char)('a' + Math.random()*26);
}else if(f == 1) {
str[i] = (char)('A' + Math.random()*26);
str[i] = (char)('0' + Math.random()*10);
return new String(str);
6.手动输入一个字符串，仅限小写字母，统计并输出每个字符在字符串中出现的次数,并输出。提示(可以用Map)
输入：aaabbbccc
&&&&&&&&&& b&3
&&& & & && c&3
package com.
import java.util.HashM
import java.util.M
* @author xcbeyond
* 下午04:47:45
* 6.手动输入一个字符串，仅限小写字母，统计并输出每个字符在字符串中出现的次数,并输出。
提示(可以用Map)
输入：aaabbbccc
输出： a 3
public class GetCharCount {
public static void main(String[] args) {
String str = &aaabbbrcc&;
String reg = &^[a-z]*$&;
if (str.matches(reg)) {
Map&Character, Integer& map = getCharCount(str);
for (Map.Entry&Character, Integer& e : map.entrySet()) {
System.out.println(e.getKey() + &: & + e.getValue());
System.out.println(&输入的字符不合法，不是小写字母&);
public static Map&Character,Integer& getCharCount(String str) {
Map&Character,Integer& map = new HashMap&Character, Integer&();
char[] arr = str.toCharArray();
for(int i = 0;i&str.length();i++) {
if(!map.containsKey(arr[i])) {
map.put(arr[i], new Integer(1));
map.put(arr[i],map.get(arr[i])+1);
7、要求实现方法public&String&addTwoBigNumber(String&s1,string&s2)
&大数相加，注意处理异常
public&class&Test{
public&String&addTwoBigNumber(String&s1,string&s2)
&&&&return&&&;
public&static&void&main(String[]&args)
&&&&&Test&test&=&new&Test();
&&&&&test.addTwoBigNumber(&&,&&)
8、比较二维数组列最小值，组成一个新数组返回。(实现核心算法，不需要使用IO)
输入：intArr&=&{{5,6,1,16},{7,3,9}}
输出：intArrs&={1,3}
package com.
import java.util.A
* @author xcbeyond
* 下午09:09:20
*8、比较二维数组列最小值，组成一个新数组返回。(实现核心算法，不需要使用IO)
* 输入：intArr = {{5,6,1,16},{7,3,9}}
* 输出：intArrs ={1,3}
public class GetColMin {
public static void main(String[] args) {
int[][] arr = {{5,6,1,16},{7,3,9}};
System.out.println(Arrays.toString(getColMin(arr)));
public static int[] getColMin(int[][] arr) {
int[] minArr = new int[arr.length];
for(int i = 0;i&arr.i++) {
int[] tmp = arr[i];
Arrays.sort(tmp);
minArr[i] = tmp[0];
return minA
9.&输入：a&aa,cat&tiger.123dd&
输出：&tiger
功能描述：键盘输入一句话
&&&&&&&&&&&&&&&输出一句话中最常的单词，如果最长的出现多次，返回第一个。
&&&&&&&&&&&&&&&这句话只包含数字字母和标点。
package com.
import java.util.ArrayL
import java.util.S
* @author xcbeyond
* 下午09:45:03
*9. 输入：a aa,cat tiger.123dd
输出： tiger
功能描述：键盘输入一句话
输出一句话中最常的单词，如果最长的出现多次，返回第一个。
这句话只包含数字字母和标点。
public class GetLongString {
public static void main(String[] args) {
System.out.println(&请输入一句话：&);
Scanner console = new Scanner(System.in);
String str = console.nextLine();
System.out.println(&最长的单词为：&+getLongString(str));
public static String getLongString(String str) {
String[] wordStr = str.split(&[ ,.0-9]&);
int sum = 0;
ArrayList&String& result = new ArrayList&String&();
for(int i = 0;i&wordStr.i++) {
if(sum&wordStr[i].length()) {
sum = wordStr[i].length();
result.add(wordStr[i]);
return result.get(result.size()-1);
10.&功能描述：将字符串中的字母全部替换成字母的下一个字母，
要是最后一位是z或Z则替换为a或A。
输入：aBxyZ
输出：bCyzA
package com.
* @author xcbeyond
* 下午10:11:02
*10. 功能描述：
将字符串中的字母全部替换成字母的下一个字母，要是最后一位是z或Z则替换为a或A。
输入：aBxyZ
输出：bCyzA
public class NextString {
public static void main(String[] args) {
String str = &aBxyZ&;
System.out.println(nextString(str));
public static String nextString(String str) {
String result = &&;
char[] arr = str.toCharArray();
for(int i = 0;i&arr.i++) {
if(arr[i] == 'z' || arr[i] == 'Z') {
arr[i] = (char)(arr[i]-25);
}else if(arr[i]&='z'&&arr[i]&='a' || arr[i]&='Z'&&arr[i]&='A') {
arr[i] = (char)(arr[i]+1);
return String.valueOf(arr);
11.&功能描述：判断一个字符串中是否只含有相同的子字符串（子串长度&=2）
输入：abab&
返回：true
输入：abcd
返回：false
要求实现方法：
public&boolean&checkString(String&data)
&&&&//TODO
&&&&return&
12.&功能描述：已知：yi&er&san&si&wu&liu&qi&ba&jiu&分别对应，
对一段只含有这几种字符串的字符串进行转换，如：
输入：yiersansan
输出：1233
要求实现方法：
public&String&trunNumber(String&data)
&&&&//TODO
&&&&return&&&;
13.&功能描述：删除字符串中字符个数最少的字符，最少字符串有多个，最少的要全部删除
&&&&&&&&&&&&&&&然后返回该子字符串。
输入：asdasdas
输出：asasas
要求实现方法：
public&String&deleteLittle(String&data)
&&&&//TODO
&&&&return&&&;
14.&功能描述：找出一个int[]中满足&2^n的数字，然后组成的新的数组
输入：{4,3，8}
输出：{4,8}
要求实现方法：
public&int[]&nextString(int[]&data)
&&&&//TODO
&&&&return&
功能描述：共data1个人，围成一圈，然后标号，从1-data1。
&&&&&&&&&&&&&&&&&然后从data2号开始从1报数，报3的出列，求出列序列。
&&&&&&&&&&&&&&&&返回一个数组
输入：3，2
输出：1,2,3
要求实现方法：
&*&data1：人数
&*&data2&:&起始位置
public&int[]&circleOut(int&data1,int&data2)
&&&&&int&outNum&=&3;
&&&&//TODO
&&&&return&
16.&功能描述：统计一个数字转为二进制后，0和1的个数，组成数组返回
输出：{1,2}
要求实现方法：
public&int[]&getNumber(int&data)
&&&&//TODO
&&&&return&
17.&功能描述：对一个二进制数的每位进行0和1反转，求翻转后的二进制所对应的十进制
要求实现方法：
public&String&getNumber(BigInteger&data)
&&&&//TODO
&&&&return&&&;
18.&功能描述：判断一个字符串中的&(&)&是否配对
输入：if(a.equals(a))
输出：true
要求实现方法：
public&boolean&isDouble(String&data)
&&&&//TODO
&&&&return&
19.&功能描述：查找一个字符串的子字符串集
输入：abab
输出：a&b&ab&ba&aba&bab&
要求实现方法：
public&List&String&&getChildren(String&data)
&&&&List&String&&list&=&new&ArrayList&String&();
&&&&//TODO
&&&&return&
20.&功能描述：数组的循环移位，
输入：{a,b,c},2
输出：{b,c,a}&
要求实现方法：
&*data&:待循环数组
&*index:移动位数
public&String[]&getChildren(String[]&data,int&index)
&&&&//TODO
&&&&return&
21.&程序实现目标：&输入一个字符，将字符转换为小写，将其对应的ASCII值加5后，输出结果。
程序要求：若其值加5后的字符值大于'z',将其转换成从a开始的字符。
输入：‘A’
输出：‘f’
22.&要求：将一个二维数组进行逆序，逆序后所有的元素行列不定，进行随机排列
23.&根据输入m数据，找出str的m个字符的所有字符串
例如&abc&&m=2
&ab&&&ac&&&bc&
&abcd&&m=3
&abc&&&acd&&&bcd&&&abd&
public&ArrayList&String&&perenum(String&str,int&m)
&&&return&
24.&分解质因数
eg：输入&28
输出&2*2*7
25.n个长度的字符串中取m个长度的组合
26.&二维数组转置
27.&功能描述：输入字符串，将该字符串中数字放到非数字的后面，并保持原有顺序不变。
例如：h3a2p0p1y----------happy3201
public&String&&childStr(String&inputStr){
28.&输入一个身份证号码（15位和18位）和一个年份，计算现在的年龄（忽略非法参数）
29.&输入一个字符串，如果是小写则转换成相应的大写字母的后五位，如果是VWXYZ则转换成abcde,其他的都不变，例如：“aDsR154+-/.”则应该输出为“FDXR154+-/.”
30.&字母转换(完成给出类中的方法)：
&1、传入大写字母，返回小写字母。
&2、返回的小写字母应为该大写字母对应的小写字母后第五个小写字母，
&&例：出入'A'，则返回f.
&3、若按2中的要求返回的字母超过z，则超过1返回a,超过2返回b,依次类推；
public&class&test{
&&public&static&void&main(String[]&args)
&&&//可写测试代码&&
&&&//需要完成的方法
&&public&char&upperToLower(char&upperCase)
&&&&&//完成代码
31.&删除一个字符串里出现次数最多的子字符串
如果有多个出现次数相同的并且出现次数最多则将多个全部删除比如abbccd得到结果&ad
32.&判断字符串首字母就大写，非首字母小写
1、如输入&Good&返回&TRUE
2、过程中不需要输出任何IO流。
33.&将一个英文语句以单词为单位逆序排放。例如“I&am&a&boy”，逆序排放后为“boy&a&am&I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
&*&反转句子
&*&@param&sentence&原句子
&*&@return&反转后的句子
public&String&reverse(String&sentence);
34.&题目背景
写出一个程序，接受一个浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整
int&round(double&d)
-4.5&四舍五入的结果是-4
4.4&四舍五入的结果是4
35.数列求和
编写程序，输入一个正整数n，求下列算式的值。要求定义和调用函数fact(k)计算k的阶乘，函数返回值的类型是double。
1+1/2!+&....&+1/n!
输出保留5位小数。
下面是一些合理的表达式的例子：
Input&&&&&&&&&5&&&&&&&&&&&&&&&&
Output&&&&&&1.71667&&&
36.&计算整数各个数位之和&
描述:&要求使用递归实现，计算整数各个数位之和。
举例：&123&--&&1+2+3&=&6
运行时间限制:&无限制&
内存限制:&无限制&
输入:&0xff&ff&ff&ff以内的整数
样例输入:&123&
样例输出:&6&
答案提示:&&&
37.提取不重复的整数&
描述:&输入一个int型32位整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
运行时间限制:&10&Sec&
内存限制:&无限制&
输入:&整数，如9876673
1、整数最后的0，请忽略，例如：输入1750，输出：571
2、负数，保留'-'在前面，例如：输入-175，输出：-571
输出:&整数，如37689
样例输入:&9876673&
样例输出:&37689&&
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 1234567891011 Copyright & &&版权所有
