上机操作编程题

Posted 2020-09-21

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了上机操作编程题相关的知识，希望对你有一定的参考价值。

一、写一个简单的缓存系统

 1 package com.wisezone.demo;
 2 
 3 import java.util.HashMap;
 4 import java.util.Map;
 5 /**
 6  * 上机操作：
 7  * 面试题——写一个简单的缓存系统
 8  * @author 王东海
 9  * @2017年6月5日
10  */
11 public class CacheDemo
12 {
13     private Map<String, Object> map = new HashMap<String,Object>();
14     
15     public Object getVaule(String key){
16         Object value = map.get(key);
17         //说明缓存中没有数据，那么需要去数据库中获取，然后放入缓存
18         if (value == null)
19         {
20             value = "说明缓存中无数据，请从数据库中读取";
21             map.put(key, value);
22         }
23         return value;
24     }
25 }

二、对上面版本优化：写一个简单的缓存系统

 1 package com.wisezone.demo;
 2 
 3 import java.util.HashMap;
 4 import java.util.Map;
 5 import java.util.concurrent.locks.ReadWriteLock;
 6 import java.util.concurrent.locks.ReentrantReadWriteLock;
 7 
 8 /**
 9  * 上面的版本即是最简单的缓存，核心在于：现在缓存集合中找数据，如果没找到再去数据库中获取。
10  * 上面是无法进行多线程应用的，所以可以讲方法改成synchronized。
11  * 然而这并不是最佳的处理多线程的方式，因为获取数据的过程只有2步：读缓存，（读数据库和写缓存）。 那么可以考虑使用读写锁机制，新版本如下：
12  * 
13  * @author 王东海
14  * @2017年6月5日
15  */
16 public class CacheDemo02
17 {
18     private Map<String, Object> cache = new HashMap<String, Object>();
19     private ReadWriteLock rwl = new ReentrantReadWriteLock();
20 
21     public Object getData(String key)
22     {
23         // 首先上读锁
24         rwl.readLock().lock();
25         // 首先从缓存中获取
26         Object value = null;
27         try
28         {
29             Thread.sleep(1000);
30             value = cache.get(key);
31             if (value == null)
32             {
33                 // 如果缓存中没有数据,那么就从数据库中获取
34                 // 但此时需要上写锁，只需要让一个进程进行写数据
35                 // 首先去除读锁，然后加上写锁
36                 rwl.readLock().unlock();
37                 rwl.writeLock().lock();
38                 try
39                 {
40                     // 此处是亮点，防止多线程运行到上一步，某个线程写完数据后
41                     // 别的线程就需要看是否有数据再决定是否进行写操作
42                     // 在写之前再读一次,防止最开始的线程都进行写操作
43                     value = cache.get(key);
44                     // 第一个线程写完后，防止后面的线程再次写数据
45                     if (value == null)
46                     {
47                         System.out.println("有线程写数据........");
48                         value = "数据库中获取";
49                         // 将数据放入缓存
50                         cache.put(key, value);
51                         System.out.println("数据写完了.......");
52                     }
53                 } finally
54                 {
55                     rwl.writeLock().unlock();
56                 }
57                 rwl.readLock().lock();
58             }
59         } catch (InterruptedException e)
60         {
61             e.printStackTrace();
62         } finally
63         {
64             rwl.readLock().unlock();
65         }
66         return value;
67     }
68 
69 }

三、求出现次数最多的那个字母及次数，如有多个重复的则都需显示出来

 1 package com.wisezone.test01;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.InputStreamReader;
 5 import java.util.Iterator;
 6 import java.util.Set;
 7 import java.util.TreeMap;
 8 /**
 9  * 一个字符串中可能包含a~z中的多个字符，如有重复，如Stringdata="aavzcadfdsfsdhshgWasdfasdf"，
10  * 求出现次数最多的那个字母及次数，如有多个重复的则都需显示出来
11  * @author 王东海
12  * @2017年6月5日
13  */
14 public class CalculateCharacter
15 {
16     private static final int COUNTER = 1;
17 
18     public static void main(String[] args)
19     {
20         try
21         {
22             // 从控制台读取
23             BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
24             System.out.print("请输入:");
25             String text = in.readLine();
26             char[] a = text.toCharArray();// 将字符串转换成一个新的字符数组
27             TreeMap<Character, Integer> m = new TreeMap<Character, Integer>();
28             for (int i = 0; i < a.length; i++)
29             {
30                 if (!m.containsKey(a[i]))
31                 {
32                     m.put(a[i], COUNTER);
33                 } else
34                 {
35                     int num = m.get(a[i]);// 返回键所指的值
36                     m.put(a[i], num + 1);
37                 }
38             }
39             // 找出出现次数最多的字符
40             Set<Character> keySet = m.keySet();
41             Iterator<Character> it = keySet.iterator();
42             int temp = 0;
43             while (it.hasNext())
44             {
45                 // System.out.println(it.next());
46                 Character key = it.next();
47                 Integer v = m.get(key);
48                 if (v > temp)
49                 {
50                     temp = v;
51                 }
52             }
53             System.out.println(m);
54             // 找出与出现次数最多字符相等的字符
55             Iterator<Character> it1 = keySet.iterator();
56             while (it1.hasNext())
57             {
58                 Character key = it1.next();
59                 Integer v = m.get(key);
60                 if (temp == v)
61                 {
62                     System.out.println("次数最多的那个字母 :" + key + "   次数: " + v);
63                 }
64             }
65         } catch (Exception e)
66         {
67             e.printStackTrace();
68         }
69     }
70 
71 }

四、一个文本文件中约有10万多行的数据，每个数据占一行(数据为一个整数)。要求：统计出总行数，并找出出现次数最多的那个整数.

  1 package com.wisezone.test01;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.BufferedWriter;
  5 import java.io.File;
  6 import java.io.FileNotFoundException;
  7 import java.io.FileReader;
  8 import java.io.FileWriter;
  9 import java.io.IOException;
 10 import java.util.ArrayList;
 11 /**
 12  * 一个文本文件中约有10万多行的数据，每个数据占一行(数据为一个整数)。要求：统计出总行数，并找出出现次数最多的那个整数.
 13  * @author 王东海
 14  * @2017年6月5日
 15  */
 16 public class FileWenBenShu
 17 {
 18     File file = new File("e:\\data.txt");
 19 
 20     /**
 21      * 产生10万随机数存入data.txt
 22      */
 23     public void statistics()
 24     {
 25 
 26         try
 27         {
 28             file.createNewFile();
 29             FileWriter fw = new FileWriter(file);
 30             BufferedWriter bw = new BufferedWriter(fw);
 31             for (int i = 1; i <= (int) (Math.random() * 100000) + 100000; i++)
 32             {
 33                 int data = (int) (Math.random() * 10000) + 1;
 34                 bw.write(String.valueOf(data));
 35                 bw.newLine();
 36             }
 37             bw.close();
 38             fw.close();
 39         } catch (IOException e)
 40         {
 41             e.printStackTrace();
 42         }
 43     }
 44 
 45     /**
 46      * 从文件中读取
 47      * 
 48      * @return
 49      */
 50     public Object[] getList()
 51     {
 52         try
 53         {
 54             ArrayList list = new ArrayList();
 55             FileReader read = new FileReader(file);
 56             BufferedReader br = new BufferedReader(read);
 57             String str = "";
 58             while ((str = br.readLine()) != null)
 59             {
 60                 list.add(str);
 61             }
 62             return list.toArray();
 63         } catch (FileNotFoundException e)
 64         {
 65             e.printStackTrace();
 66             return null;
 67         } catch (IOException e)
 68         {
 69             e.printStackTrace();
 70             return null;
 71         }
 72     }
 73 
 74     public int getSize()
 75     {// 统计出总行数
 76         Object[] o = getList();
 77         return o.length;
 78     }
 79 
 80     public int[] getMaxSameNo()
 81     {// 找出出现次数最多的那个数组
 82 
 83         Object o[] = getList();
 84 
 85         int no[] = new int[o.length];
 86         for (int i = 0; i < o.length; i++)
 87         {
 88             no[i] = Integer.parseInt((String) o[i]);
 89 
 90         }
 91         java.util.Arrays.sort(no);// 数组排序
 92         for (int i = 0; i < no.length; i++)
 93         {
 94             // System.out.println("array[ " + i + "]= " + no[i]);
 95         }
 96 
 97         int maxsum = getSum(no);// 出现次数最多的数到底出现了几次
 98         return getInt(no, maxsum);// 找出出现次数最多的那个数
 99 
100     }
101 
102     public int getSum(int[] no)
103     {// 此方法返回出现次数最多的数到底出现了几次！
104         ArrayList sumlist = new ArrayList();
105         int sum = 1;
106         for (int i = 0; i < no.length - 1; i++)
107         {
108             if (no[i] == no[i + 1])
109             {
110                 sum++;// 相临两个相等计数器+1
111             } else
112             {
113                 // 不相等向集合里加入
114                 sumlist.add(sum);
115                 // 计数器复位继续比较
116                 sum = 1;
117                 continue;
118             }
119         }
120         int max = 0;
121         for (int i = 0; i < sumlist.size(); i++)
122         {// 此循环取出集合里最大的数！
123             if (Integer.parseInt(sumlist.get(i).toString()) > max)
124             {
125                 max = Integer.parseInt(sumlist.get(i).toString());
126             }
127         }
128         return max;
129     }
130 
131     public int[] getInt(int[] no, int a)
132     {// 此方法返回出现次数为a的数组，可能有多个数字出现相同的次数的情况,所以返回的是数组
133         ArrayList sumlist = new ArrayList();
134         int sum = 1;
135         for (int i = 0; i < no.length - 1; i++)
136         {
137             if (no[i] == no[i + 1])
138             {
139                 sum++;
140             } else
141             {
142                 if (sum == a)
143                 {
144                     sumlist.add(no[i]);
145                     System.out.println(no[i] + "一共出现了 " + a + "次！ ");
146                 } else
147                 {
148                     sum = 1;
149                     continue;
150                 }
151 
152             }
153         }
154         int aa[] = new int[sumlist.size()];
155         for (int i = 0; i < aa.length; i++)
156         {
157             aa[i] = Integer.parseInt((sumlist.get(i).toString()));
158         }
159         return aa;
160 
161     }
162 
163     public static void main(String[] args)
164     {
165         FileWenBenShu test = new FileWenBenShu();
166         test.statistics();
167         int count = test.getSize();
168         System.out.println("一共有 " + count + "条记录! ");
169         int[] max = test.getMaxSameNo();
170         System.out.println("出现次数最多的数为: ");
171         for (int i = 0; i < max.length; i++)
172         {
173             System.out.print(max[i] + ", ");
174         }
175     }
176 }

五、有N个人买可乐，每5空瓶送1瓶，问共需要买多少瓶？

 1 package com.wisezone.test01;
 2 /**
 3  * 有N个人买可乐，每5空瓶送1瓶，问共需要买多少瓶？ 
 4  * @author 王东海
 5  * @2017年6月5日
 6  */
 7 public class PingZiShu
 8 {
 9     public static void main(String[] args)
10     {
11         int n = 31;
12         int drinked = 0;// 喝到可乐的人数
13         int i = 1;
14         int bottles = 0;// 买的可乐瓶数
15         int left = 0;
16         int modLeft = 0;// 最后剩下的人数
17         if (n <= 5)
18         {
19             bottles = n;
20         } else
21         {
22             while (true)
23             {
24                 bottles += 5;
25                 drinked += 6;
26                 while (i / 5 >= 1)
27                 {
28                     drinked = drinked + i / 5;
29                     i = i / 5;
30                 }
31                 left = n - drinked;
32                 modLeft = left / 5;
33                 if (modLeft == 0)
34                 {
35                     bottles += modLeft;
36                     if (drinked != n)
37                     {
38                         bottles += n - drinked;
39                     }
40                     break;
41                 }
42                 i++;
43             }
44         }
45         System.out.println("We need " + bottles + "bottles");
46     }
47 }

六、将54张牌1~54随机分发到数组

 1 package com.wisezone.test01;
 2 /**
 3  * 将54张牌1~54随机分发到数组
 4  * @author 王东海
 5  * @2017年6月5日
 6  */
 7 public class PlayCard
 8 {
 9 
10     public static void main(String[] args)
11     {
12         final int CART_ARRAY_LEN = 54;
13         int[] carts = new int[CART_ARRAY_LEN];
14         for (int i = 0; i < CART_ARRAY_LEN; i++)
15         {
16             carts[i] = i + 1;
17         }
18         for (int i = 0; i < CART_ARRAY_LEN; i++)
19         {
20             int rdmNum1 = (int) (Math.random() * 54);
21             int rdmNum2 = (int) (Math.random() * 54);
22             int temp = carts[rdmNum1];
23             carts[rdmNum1] = carts[rdmNum2];
24             carts[rdmNum2] = temp;
25         }
26         for (int i = 0; i < CART_ARRAY_LEN; i++)
27         {
28             System.out.print(carts[i]+",");
29         }
30     }
31 
32 }

七、编程实现统计字符串中字符的个数，数字的个数以及其它字符的个数

 1 package com.wisezone.test01;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 /**
 7  * 编程实现统计字符串中字符的个数，数字的个数以及其它字符的个数
 8  * @author 王东海
 9  * @2017年6月5日
10  */
11 public class Shuzi
12 {
13     public static void show(String s)
14     {
15         int x = 0, y = 0, z = 0;
16         for (int i = 0; i < s.length(); i++)
17         {
18             char ch = s.charAt(i);// 字符串中第i个字符
19             if (ch > ‘0‘ && ch < ‘9‘)
20             {
21                 x++;
22             } else if ((ch >= ‘A‘ && ch <= ‘Z‘) || (ch >= ‘a‘ && ch <= ‘z‘))
23             {
24                 y++;
25             } else
26             {
27                 z++;
28             }
29         }
30         System.out.println("数字的个数为：" + x);
31         System.out.println("字母的个数为：" + y);
32         System.out.println("其它个数为：" + z);
33     }
34 
35     public static void main(String[] args) throws IOException
36     {
37         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
38         System.out.println("请输入你要统计的字符串：");
39         String str = br.readLine();
40         show(str);
41     }
42 }

八、定义一串字母的字符串，求出现最多的那个字母，出现了多少次！

 1 package com.wisezone.test01;
 2 
 3 import java.util.HashMap;
 4 import java.util.Map;
 5 /**
 6  * 定义一串字母的字符串，求出现最多的那个字母，出现了多少次！ 
 7  * @author 王东海
 8  * @2017年6月5日
 9  */
10 public class Test
11 {
12     public static void main(String[] args)
13     {
14         String str = "aaabbc";
15         Map<Character, Integer> d = new HashMap<Character, Integer>();
16         for (int i = 0; i < str.length(); i++)
17         {
18             char c = str.charAt(i);
19             if (d.containsKey(c))
20             {
21                 d.put(c, d.get(c) + 1);
22             } else
23             {
24                 d.put(c, 1);
25             }
26         }
27         System.out.println(d);
28     }
29 
30 }

九、JAVA编程题:字符串"yekmaakkccekymbvb",求出字符串中有多少种字符?

 1 package com.wisezone.test01;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 /**
 6  * JAVA编程题:字符串"yekmaakkccekymbvb",求出字符串中有多少种字符?
 7  * @author 王东海
 8  * @2017年6月5日
 9  */
10 public class TongJiZiFuShu
11 {
12     public static void main(String[] args)
13     {
14         Set set = new HashSet();  
15         String s1 = "yekmaakkccekymbvb"; 
16 //        String s1 = "abcda";  
17         String blank = "";  
18         char c;  
19         for(int i=0; i<s1.length(); i++){  
20              c = s1.charAt(i);  
21              //System.out.println(c);  
22              set.add(blank+c);  
23         }  
24         System.out.println("共有： "+set.size()+" 种字符");  
25     }
26 }

十、给你一组字符串如：iu7i8hy4jnb2，让你编程输出里面的数字：7842

 1 package com.wisezone.test01;
 2 /**
 3  * 给你一组字符串如：iu7i8hy4jnb2，让你编程输出里面的数字：7842 
 4  * @author 王东海
 5  * @2017年6月5日
 6  */
 7 public class ZhengZe
 8 {
 9     public static void main(String[] args)
10     {
11         String s = "iu7i8hy4jnb2";     
12         String newStr = s.replaceAll("[a-z]", "");     
13         System.out.println(newStr);  
14     }
15 }

十一、给你一组字符串让你把它倒叙输出

 1 package com.wisezone.test01;
 2 
 3 /**
 4  * 给你一组字符串让你把它倒叙输出 
 5  * @author 王东海
 6  * @2017年6月5日
 7  */
 8 public class ZiFuChuangDaoXuShuChu
 9 {
10     public static String reverseStr(String str)
11     {
12         StringBuffer sb = new StringBuffer(str);
13         sb.reverse();
14         return sb.toString();
15     }
16 
17     public static void main(String[] args)
18     {
19         System.out.println(reverseStr("abcdfe"));
20     }
21 }

十二、打印出杨辉三角形（要求打印出10行如下图）

 1 package com.wisezon.chart;
 2 
 3 public class ArrayYangHui
 4 {
 5     /*题目：打印出杨辉三角形（要求打印出10行如下图）      
 6                    1   
 7                  1   1   
 8                1   2   1   
 9              1   3   3   1   
10            1   4   6   4   1   
11          1   5   10   10   5   1   
12        1   6   15   20   15   6   1   
13      1   7   21   35   35   21   7   1   
14    1   8   28   56   70   56   28   8   1   
15  1   9   36   84   126   126   84   36   9   1   
16  */
17 
18     public static void main(String[] args)
19     {
20         int[][] a = new int[10][10];
21         for (int i = 0; i < 10; i++)
22         {
23             a[i][i] = 1;
24             a[i][0] = 1;
25         }
26         for (int i = 0; i < 10; i++)
27         {
28             for (int j = 1; j < i; j++)
29             {
30                 a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
31             }
32 
33         }
34         for (int i = 0; i < 10; i++)
35         {
36             for (int k = 0; k < 2 * (10 - i); k++)
37             {
38                 System.out.print(" ");
39             }
40             for (int j = 0; j <= i; j++)
41             {
42                 System.out.print(a[i][j] + "   ");
43             }
44             System.out.println();
45         }
46 
47     }
48 
49 }

十三、打印出这个图形

  1 package com.wisezon.chart;
  2 
  3 public class DengYao
  4 {
  5     //打印出这个图形
  6  /*     *
  7        ***
  8       *****
  9      *******
 10     *********   */
 11     public static void printGra()
 12     {
 13         for (int a = 0;a <= 9;a++)
 14         {
 15             if (a % 2 == 0)
 16             {
 17                 for (int b = 0;b <= (9-1-a)/2;b++)
 18                 {
 19                     System.out.print(" ");
 20                 }
 21                 for (int b = 0;b <= a ;b++)
 22                 {
 23                     System.out.print("*");
 24                 }
 25                 System.out.println();
 26             }
 27             
 28         }
 29     }
 30     
 31     //打印出下列9行9列图形
 32 /*         *
 33        ***
 34       *****
 35      *******
 36     *********
 37      ******* 
 38       *****
 39        ***
 40         *         */
 41     public static void chart()
 42     {
 43         for (int i = 0; i < (9 + 1) / 2 ;i++)
 44         {
 45             for (int j = 0;j < 9 / 2 - i;j++)
 46             {
 47                 System.out.print(" ");
 48             }
 49             for (int k = 1;k < (i + 1) * 2;k++)
 50             {
 51                 System.out.print("*");
 52             }
 53             System.out.println();
 54             
 55         }
 56         for (int i = 1 ; i <= 9 / 2;i++)
 57         {
 58             for (int j = 1 ;j <= i; j++)
 59             {
 60                 System.out.print(" ");
 61             }
 62             for (int k = 1; k <= 9- 2 * i;k++)
 63             {
 64                 System.out.print("*");
 65             }
 66             System.out.println();
 67         }
 68     }
 69     
 70     //打印出这个图形
 71     /*    *
 72          ***
 73          *****
 74          *******
 75          *********
 76          *******
 77          *****
 78          ***
 79          *        */
 80     public static void chart01()
 81     {
 82         for (int i = 0; i < (9 + 1) / 2 ;i++)
 83         {
 84             for (int j = 0;j < 9 / 2 - i;j++)
 85             {
 86                 System.out.print("");
 87             }
 88             for (int k = 1;k < (i + 1) * 2;k++)
 89             {
 90                 System.out.print("*");
 91             }
 92             System.out.println();
 93             
 94         }
 95         for (int i = 1 ; i <= 9 / 2;i++)
 96         {
 97             for (int j = 1 ;j <= i; j++)
 98             {
 99                 System.out.print("");
100             }
101             for (int k = 1; k <= 9- 2 * i;k++)
102             {
103                 System.out.print("*");
104             }
105             System.out.println();
106         }
107     }
108     public static void main(String[] args)
109     {
110         chart();
111         chart01();
112 
113     }
114 
115 }

十四、打印图形

 1 package com.wisezon.chart;
 2 
 3 public class JiShuSanJiaoXing
 4 {
 5 
 6     //3、打印图形
 7      /*        *
 8              ***
 9              *****
10              *******        */
11     
12     public static void aaa()
13     {
14         for (int i = 0; i < (9 + 1) / 2 ;i++)
15         {
16             for (int j = 0;j < 9 / 2 - i;j++)
17             {
18                 System.out.print("");
19             }
20             for (int k = 1;k < (i + 1) * 2;k++)
21             {
22                 System.out.print("*");
23             }
24             System.out.println();
25             
26         }
27         
28     }
29 
30     public static void main(String[] args)
31     {
32         aaa();
33     }
34 
35 }

十五、打印出空心五角星

  1 package com.wisezon.chart;
  2 
  3 public class KongXinWuJiaoXing
  4 {
  5 
  6     // 打印出空心五角星
  7     // K表示区域总共4个,i表示行,j表示列  空心 
  8     public static void pp3(int n)
  9     {
 10         int i, i2, i3, i4, i5, j, j2, j3, j4, j5, j6, k = 0;
 11         int m2 = 0;
 12         int m3 = 0;
 13         for (k = 1; k <= 4; k++)
 14         {
 15             // 第一步          
 16             if (k == 1)
 17             {
 18                 for (i = 0; i < n; i++)
 19                 {
 20                     // 最大列数为6*n
 21                     for (j = 0; j < 6 * n; j++)
 22                     {
 23                         if ((j < 3 * n - i + 1 && j >= 3 * n - i) || (j <= 3 * n + i && j > 3 * n + i - 1))
 24                         {
 25                             System.out.print("*");
 26                         } else
 27                         {
 28                             System.out.print(" ");
 29                         }
 30                     }
 31                     System.out.println();
 32                 }
 33             }
 34             // 第二步
 35             if (k == 2)
 36             {
 37                 for (j2 = 1; j2 <= 6 * n + 1; j2++)
 38                 {
 39                     if ((j2 <= 2 * n + 1) || (j2 > 4 * n && j2 <= 6 * n))
 40                     {
 41                         System.out.print("*");
 42                     } else
 43                     {
 44                         System.out.print(" ");
 45 
 46                     }
 47                 }
 48                 for (i2 = n + 1; i2 < n + 2; i2++)
 49                 {
 50                     System.out.println();
 51                     for (j3 = 0; j3 < 6 * n; j3++)
 52                     {
 53                         if ((j3 >= 3 && j3 < 4) || (j3 > 6 * n - 4 && j3 <= 6 * n - 3))
 54                         {
 55                             System.out.print("*");
 56                         } else
 57                         {
 58                             System.out.print(" ");
 59                         }
 60                     }
 61                 }
 62                 for (i3 = n + 2; i3 < n + 3; i3++)
 63                 {
 64                     System.out.println();
 65                     for (j4 = 0; j4 <= 6 * n; j4++)
 66                     {
 67                         if ((j4 >= 5 && j4 < 6) || (j4 > 6 * n - 6 && j4 <= 6 * n - 5))
 68                         {
 69                             System.out.print("*");
 70                         } else
 71                         {
 72                             System.out.print(" ");
 73                         }
 74                     }
 75                 }
 76             }
 77             // 第三步
 78             if (k == 3)
 79             {
 80                 for (i4 = 0; i4 < n - 3; i4++)
 81                 {
 82                     System.out.println();
 83                     for (j5 = 0; j5 < 6 * n; j5++)
 84                     {
 85                         if ((j5 > 5 + m2 && j5 <= 5 + m2 + 1)
 86                                 || ((j5 >= 6 * n - (5 + m2) - 1) && j5 < (6 * n - (5 + m2))))
 87                         {
 88                             System.out.print("*");
 89                         } else
 90                         {
 91                             // 显示该部分中间那个点
 92                             if (i4 == n - 4 && j5 == 3 * n)
 93                             {
 94                                 System.out.print("*");
 95                             } else
 96                             {
 97                                 System.out.print(" ");
 98                             }
 99                         }
100                     }
101                     m2++;
102                 }
103             }
104             // 第四步
105             if (k == 4)
106             {
107                 for (i5 = 0; i5 < n - 1; i5++)
108                 {
109                     System.out.println();
110                     for (j6 = 0; j6 < 6 * n; j6++)
111                     {
112                         if ((j6 >= n + 1 - m3 && j6 < n + 2 - m3)
113                                 || (j6 >= 3 * n - 3 - 3 * m3 && j6 < 3 * n - 2 - 3 * m3)
114                                 || ((j6 > 3 * n + 2 + 3 * m3) && j6 <= 3 * n + 2 + 3 * m3 + 1)
115                                 || (j6 > 5 * n + m3 - 2 && (j6 <= 5 * n + m3 - 1)))
116                         {
117                             System.out.print("*");
118                         } else
119                         {
120                             System.out.print(" ");
121                         }
122                     }
123                     m3++;
124                 }
125             }
126         }
127     }
128 
129     public static void main(String[] args)
130     {
131         pp3(5);
132 
133     }
134 
135 }

十六、打印出一个9列的空心菱形

 1 package com.wisezon.chart;
 2 
 3 public class LiXing
 4 {
 5     //打印出一个9列的空心菱形
 6  /*       *
 7            * *
 8           *   *
 9          *     *
10         *       *
11        *         *
12         *       *
13          *     *
14           *   *
15            * *
16             *         */
17 
18     public static void rhomb(int n)
19     {
20         // 上半部分
21         for (int i = 0; i < n - 1; i++)
22         {
23             if (i % 2 == 0)
24             {
25                 // 左上的空白
26                 for (int j = 0; j < (n - 1 - i) / 2; j++)
27                 {
28                     System.out.print(" ");
29                 }
30                 System.out.print("*");
31                 // 中上的空白
32                 for (int j = 0; j < i - 1; j++)
33                 {
34                     System.out.print(" ");
35                 }
36                 if (i != 0)
37                 {
38                     System.out.print("*");
39                 }
40                 System.out.println();
41             }
42         }
43         // 下半部分
44         for (int i = n - 1; i >= 0; i--)
45         {
46             if (i % 2 == 0)
47             {
48                 for (int j = 0; j < (n - 1 - i) / 2; j++)
49                 {
50                     System.out.print(" ");
51                 }
52                 System.out.print("*");
53                 for (int j = 0; j < i - 1; j++)
54                 {
55                     System.out.print(" ");
56                 }
57 
58                 if (i != 0)
59                 {
60                     System.out.print("*");
61                 }
62                 System.out.println();
63             }
64         }
65     }
66     public static void main(String[] args)
67     {
68         rhomb(11);
69 
70     }
71 
72 }

图形

 1 package com.wisezon.chart;
 2 
 3 public class SanJiaoXing 
 4 {
 5     //定义一个方法，打印出下面的形状
 6         /*      
 7                 *8个空格1个星号
 8                **7个空格2个星号
 9               ***6个空格3个星号
10              ****5个空格4个星号
11             *****4个空格5个星号
12            ******3个空格6个星号
13           *******2个空格7个星号
14          ********1个空格8个星号
15         *********0个空格9个星号
16         */
17     public static void opp()
18     {
19         for(int a=1;a<=9;a++)
20         {
21             for(int b=1;b<=9-a;b++)
22             {
23                 System.out.print(" ");
24             }
25             for(int c=1;c<=a;c++)
26             {
27                 System.out.print("*");
28             }
29             System.out.println();
30         }
31     }
32     
33     // 定义一个方法，打印出下面的图形
34             /*
35                * 
36                ** 
37                *** 
38                **** 
39                ***** 
40                ****** 
41                ******* 
42                ******** 
43                *********
44              */
45     public static void name()
46     {
47         for(int i=1;i<=9;i++)
48         {
49             for(int j=1;j<=i;j++)
50             {
51                 System.out.print("*");
52             }
53             System.out.println();
54         }
55     }
56     public static void main(String[] args)
57     {
58         opp();
59         System.out.println();
60         name();
61     }
62 }

打印出实心五角星

  1 package com.wisezon.chart;
  2 
  3 public class ShiXinWuJiaoXing
  4 {
  5     // 打印出实心五角星
  6     // K表示区域总共4个,a表示行,b表示列     实心
  7     public static void ww(int n)
  8     {
  9         int a, a2, a3, a4, a5, b, b2, b3, b4, b5, k = 0;
 10         int m2 = 0;
 11         int m3 = 0;
 12         for (k = 1; k <= 4; k++)
 13         {
 14             // part 1
 15             if (k == 1)
 16             {
 17                 for (a = 0; a < n; a++)
 18                 {
 19                     System.out.println();
 20                     // 最大列数为6*n
 21                     for (b = 0; b < 6 * n; b++)
 22                     {
 23                         if (b <= 3 * n + a && b >= 3 * n - a)
 24                         {
 25                             System.out.print("*");
 26                         } else
 27                         {
 28                             System.out.print(" ");
 29                         }
 30                     }
 31                 }
 32             }
 33             // part 2
 34             if (k == 2)
 35             {
 36                 System.out.println("");
 37                 for (a = 1; a <= 6 * n + 1; a++)
 38                 {
 39                     System.out.print("*");
 40                 }
 41                 for (a2 = n + 1; a2 < n + 2; a2++)
 42                 {
 43                     System.out.println();
 44                     for (b2 = 0; b2 < 6 * n; b2++)
 45                     {
 46                         if (b2 >= 3 && b2 <= 6 * n - 3)
 47                         {
 48                             System.out.print("*");
 49                         } else
 50                         {
 51                             System.out.print(" ");
 52                         }
 53                     }
 54                 }
 55                 for (a3 = n + 2; a3 < n + 3; a3++)
 56                 {
 57                     System.out.println();
 58                     for (b3 = 0; b3 <= 6 * n; b3++)
 59                     {
 60                         if (b3 >= 5 && b3 <= 6 * n - 5)
 61                         {
 62                             System.out.print("*");
 63                         } else
 64                         {
 65                             System.out.print(" ");
 66                         }
 67                     }
 68                 }
 69             }
 70             // part 3
 71             if (k == 3)
 72             {
 73                 for (a4 = 0; a4 < n - 3; a4++)
 74                 {
 75                     System.out.println();
 76                     for (b4 = 0; b4 < 6 * n; b4++)
 77                     {
 78                         if (b4 > 5 + m2 && b4 < 6 * n - (5 + m2))
 79                         {
 80                             System.out.print("*");
 81                         } else
 82                         {
 83                             System.out.print(" ");
 84                         }
 85                     }
 86                     m2++;
 87                 }
 88             }
 89             // part 4
 90             if (k == 4)
 91             {
 92                 for (a5 = 0; a5 < n - 1; a5++)
 93                 {
 94                     System.out.println();
 95                     for (b5 = 0; b5 < 6 * n; b5++)
 96                     {
 97                         if ((b5 >= n + 1 - m3 && b5 < 3 * n - 2 - 3 * m3)
 98                                 || ((b5 > 3 * n + 2 + 3 * m3) && (b5 <= 5 * n + m3 - 1)))
 99                         {
100                             System.out.print("*");
101                         } else
102                         {
103                             System.out.print(" ");
104                         }
105                     }
106                     m3++;
107                 }
108             }
109         }
110     }
111 
112     public static void main(String[] args)
113     {
114         ww(5);
115     }
116 }

图形

  1 package com.wisezon.chart;
  2 
  3 public class ShiXinWuJiaoXing
  4 {
  5     // 打印出实心五角星
  6     // K表示区域总共4个,a表示行,b表示列     实心
  7     public static void ww(int n)
  8     {
  9         int a, a2, a3, a4, a5, b, b2, b3, b4, b5, k = 0;
 10         int m2 = 0;
 11         int m3 = 0;
 12         for (k = 1; k <= 4; k++)
 13         {
 14             // part 1
 15             if (k == 1)
 16             {
 17                 for (a = 0; a < n; a++)
 18                 {
 19                     System.out.println();
 20                     // 最大列数为6*n
 21                     for (b = 0; b < 6 * n; b++)
 22                     {
 23                         if (b <= 3 * n + a && b >= 3 * n - a)
 24                         {
 25                             System.out.print("*");
 26                         } else
 27                         {
 28                             System.out.print(" ");
 29                         }
 30                     }
 31                 }
 32             }
 33             // part 2
 34             if (k == 2)
 35             {
 36                 System.out.println("");
 37                 for (a = 1; a <= 6 * n + 1; a++)
 38                 {
 39                     System.out.print("*");
 40                 }
 41                 for (a2 = n + 1; a2 < n + 2; a2++)
 42                 {
 43                     System.out.println();
 44                     for (b2 = 0; b2 < 6 * n; b2++)
 45                     {
 46                         if (b2 >= 3 && b2 <= 6 * n - 3)
 47                         {
 48                             System.out.print("*");
 49                         } else
 50                         {
 51                             System.out.print(" ");
 52                         }
 53                     }
 54                 }
 55                 for (a3 = n + 2; a3 < n + 3; a3++)
 56                 {
 57                     System.out.println();
 58                     for (b3 = 0; b3 <= 6 * n; b3++)
 59                     {
 60                         if (b3 >= 5 && b3 <= 6 * n - 5)
 61                         {
 62                             System.out.print("*");
 63                         } else
 64                         {
 65                             System.out.print(" ");
 66                         }
 67                     }
 68                 }
 69             }
 70             // part 3
 71             if (k == 3)
 72             {
 73                 for (a4 = 0; a4 < n - 3; a4++)
 74                 {
 75                     System.out.println();
 76                     for (b4 = 0; b4 < 6 * n; b4++)
 77                     {
 78                         if (b4 > 5 + m2 && b4 < 6 * n - (5 + m2))
 79                         {
 80                             System.out.print("*");
 81                         } else
 82                         {
 83                             System.out.print(" ");
 84                         }
 85                     }
 86                     m2++;
 87                 }
 88             }
 89             // part 4
 90             if (k == 4)
 91             {
 92                 for (a5 = 0; a5 < n - 1; a5++)
 93                 {
 94                     System.out.println();
 95                     for (b5 = 0; b5 < 6 * n; b5++)
 96                     {
 97                         if ((b5 >= n + 1 - m3 && b5 < 3 * n - 2 - 3 * m3)
 98                                 || ((b5 > 3 * n + 2 + 3 * m3) && (b5 <= 5 * n + m3 - 1)))
 99                         {
100                             System.out.print("*");
101                         } else
102                         {
103                             System.out.print(" ");
104                         }
105                     }
106                     m3++;
107                 }
108             }
109         }
110     }
111 
112     public static void main(String[] args)
113     {
114         ww(5);
115     }
116 }

图形

 1 package com.wisezon.chart;
 2 
 3 public class Test02
 4 {
 5     public static void chart()
 6     {
 7     //1、打印图形
 8     /*        ****
 9              ****
10              ****
11              ****
12              ****
13              ****
14              ****    */
15     
16         for (int i = 0;i < 7;i++)
17         {
18             for (int j = 0;j < 4;j++)
19             {
20                 System.out.print("*");
21             }
22             System.out.println();
23         }
24         
25     }
26     
27     //2、打印图形
28      /*        *
29               **
30               ***
31               ****    */
32     
33     public static void chart2()
34     {
35         for (int i = 0;i < 4;i++)
36         {
37             for (int j = 0;j < i+1;j++)
38             {
39                 System.out.print("*");
40             }
41             System.out.println();
42         }
43     }
44     
45     //3、打印图形
46      /*        *
47              ***
48              *****
49              *******        */
50     
51     public static void chart3()
52     {
53         for (int i = 1;i <= 7;i+=2)
54         {
55             for (int j = 1;j <= i;j++)
56             {
57                 System.out.print("*");
58             }
59             System.out.println();
60         }
61     }
62     
63     //4、打印图形
64      /*        ***
65               ***
66                ***        */
67     
68     public static void chart4()
69     {
70         for (int i = 0; i < 3; i++)
71         {
72             for (int j = 0; j < i; j++)
73             {
74                 System.out.print(" ");
75             }
76             for (int k = 0; k < 3; k++)
77             {
78                 System.out.print("*");
79             }
80             System.out.println();
81         }
82     }
83     
84     
85     public static void main(String[] args)
86     {
87         chart();
88         System.out.println("===============");
89         chart2();
90         System.out.println("===============");
91         chart3();
92         System.out.println("===============");
93         chart4();
94         System.out.println("===============");
95         
96     }
97     
98 }

图形

  1 package com.wisezon.chart;
  2 
  3 public class Test03
  4 {
  5     public static void chart()
  6     {
  7     //1、打印图形
  8     /*        ****
  9              ****
 10              ****
 11              ****
 12              ****
 13              ****
 14              ****    */
 15     
 16         for (int i = 0;i < 7;i++)
 17         {
 18             for (int j = 0;j < 4;j++)
 19             {
 20                 System.out.print("*");
 21             }
 22             System.out.println();
 23         }
 24         
 25     }
 26     
 27     //2、打印图形
 28      /*        *
 29               **
 30               ***
 31               ****    */
 32     
 33     public static void chart2()
 34     {
 35         for (int i = 0;i < 4;i++)
 36         {
 37             for (int j = 0;j < i+1;j++)
 38             {
 39                 System.out.print("*");
 40             }
 41             System.out.println();
 42         }
 43     }
 44     
 45     //3、打印图形
 46      /*        *
 47              ***
 48              *****
 49              *******        */
 50     
 51     public static void chart3()
 52     {
 53         for (int i = 1;i <= 7;i+=2)
 54         {
 55             for (int j = 1;j <= i;j++)
 56             {
 57                 System.out.print("*");
 58             }
 59             System.out.println();
 60         }
 61     }
 62     
 63     //4、打印图形
 64      /*        ***
 65               ***
 66                ***        */
 67     
 68     public static void chart4()
 69     {
 70         for (int i = 0; i < 3; i++)
 71         {
 72             for (int j = 0; j < i; j++)
 73             {
 74                 System.out.print(" ");
 75             }
 76             for (int k = 0; k < 3; k++)
 77             {
 78                 System.out.print("*");
 79             }
 80             System.out.println();
 81         }
 82     }
 83     
 84     //5、打印图形
 85      /*    ***
 86           ***
 87          ***        */
 88      
 89     public static void chart5()
 90     {
 91         for (int i = 0; i < 3; i++)
 92         {
 93             for (int j = 1; j < 3-i; j++)
 94             {
 95                 System.out.print(" ");
 96             }
 97             for (int j = 0; j < 3; j++)
 98             {
 99                 System.out.print("*");
100             }
101             System.out.println("");
102         }
103     }
104     
105     //6、打印图形
106      /*        *****
107              ****
108              ***
109              **
110              *        */
111     public static void chart6()
112     {
113         for (int i = 0;i < 5;i++)
114         {
115             for (int j = 0;j < 5 - i;j++)
116             {
117                 System.out.print("*");
118             }
119             System.out.println();
120         }
121     }
122     
123     //7、打印图形
124      /*        ****
125                ***
126                 **
127                  *        */
128     public static void chart7()
129     {
130         for (int i = 0; i < 4; i++)
131         {
132             for (int j = 0; j < i; j++)
133             {
134                 System.out.print(" ");
135             }
136             for (int k = 0; k < 4 - i; k++)
137             {
138                 System.out.print("*");
139             }
140             System.out.println();
141         }
142     }
143     
144     //8、打印图形
145     /*    *
146           **
147            ***
148            ****
149             *****
150              ******
151               *******
152                ********
153                 *********  */
154     public static void chart8()
155     {
156         for (int q = 0;q < 9; q++)
157         {
158             for (int w = 0; w < q; w++)
159             {
160                 System.out.print(" ");
161             }
162             for (int z = 0; z <= q; z++)
163             {
164                 System.out.print("*");
165             }
166             System.out.println();
167                 
168         }
169     }
170     
171     
172     //9、打印出这个图形
173  /*     *
174        ***
175       *****
176      *******
177     *********   */
178     public static void chart9()
179     {
180         for (int a = 0;a <= 9;a++)
181         {
182             if (a % 2 == 0)
183             {
184                 for (int b = 0;b <= (9-1-a)/2;b++)
185                 {
186                     System.out.print(" ");
187                 }
188                 for (int b = 0;b <= a ;b++)
189                 {
190                     System.out.print("*");
191                 }
192                 System.out.println();
193             }
194             
195         }
196     }
197     
198     //10、打印出下列9行9列图形
199 /*         *
200        ***
201       *****
202      *******
203     *********
204      ******* 
205       *****
206        ***
207         *         */
208     public static void chart10()
209     {
210         for (int i = 0; i < (9 + 1) / 2 ;i++)
211         {
212             for (int j = 0;j < 9 / 2 - i;j++)
213             {
214                 System.out.print(" ");
215             }
216             for (int k = 1;k < (i + 1) * 2;k++)
217             {
218                 System.out.print("*");
219             }
220             System.out.println();
221             
222         }
223         for (int i = 1 ; i <= 9 / 2;i++)
224         {
225             for (int j = 1 ;j <= i; j++)
226             {
227                 System.out.print(" ");
228             }
229             for (int k = 1; k <= 9- 2 * i;k++)
230             {
231                 System.out.print("*");
232             }
233             System.out.println();
234         }
235     }
236     
237     //11、打印出这个图形
238     /*    *
239          ***
240          *****
241          *******
242          *********
243          *******
244          *****
245          ***
246          *        */
247     public static void chart11()
248     {
249         for (int i = 0; i < (9 + 1) / 2 ;i++)
250         {
251             for (int j = 0;j < 9 / 2 - i;j++)
252             {
253                 System.out.print("");
254             }
255             for (int k = 1;k < (i + 1) * 2;k++)
256             {
257                 System.out.print("*");
258             }
259             System.out.println();
260             
261         }
262         for (int i = 1 ; i <= 9 / 2;i++)
263         {
264             for (int j = 1 ;j <= i; j++)
265             {
266                 System.out.print("");
267             }
268             for (int k = 1; k <= 9- 2 * i;k++)
269             {
270                 System.out.print("*");
271             }
272             System.out.println();
273         }
274     }
275     public static void main(String[] args)
276     {
277         chart();
278         System.out.println("===============");
279         chart2();
280         System.out.println("===============");
281         chart3();
282         System.out.println("===============");
283         chart4();
284         System.out.println("===============");
285         chart5();
286         System.out.println("===============");
287         chart6();
288         System.out.println("===============");
289         chart7();
290         System.out.println("===============");
291         chart8();
292         System.out.println("===============");
293         chart9();
294         System.out.println("===============");
295         chart10();
296         System.out.println("===============");
297         chart11();
298         
299     }
300     
301 }

求这个文件中的总数量，并去重

 1 package com.wisezone.OracleTest;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.File;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileReader;
 7 import java.io.IOException;
 8 import java.util.HashSet;
 9 //求这个文件中的总数量，并去重
10 
11 public class A
12 {
13     public static void main(String[] args)
14     {
15         File file = new File("D:/YY语音/新建文本文档 (2).txt/");
16         try
17         {
18             FileReader fileReader = new FileReader(file);
19             BufferedReader bufferedReader = new BufferedReader(fileReader);
20             
21             try
22             {
23                 HashSet<String> hashSet = new HashSet<String>();
24                 
25                 int count = 0;
26                 String a = null;
27                 while ((a = bufferedReader.readLine()) != null)
28                 {
29                     hashSet.add(a);
30                 }
31                 for (String string : hashSet)
32                 {
33                     count++;
34                 }
35                 System.out.println(count);
36 
37             } catch (IOException e)
38             {
39                 e.printStackTrace();
40             }
41 
42         } catch (FileNotFoundException e)
43         {
44             e.printStackTrace();
45         }
46 
47     }
48 }

实现一个十进制分别转为二进制、十六进制、八进制的小程序，要求：在控制台实现出来

 1 package com.wisezone.Test11;
 2 
 3 import java.util.Scanner;
 4 
 5 public class DecimalConversion
 6 {
 7     //实现一个十进制分别转为二进制、十六进制、八进制的小程序，要求：在控制台实现出来
 8     public static void main(String[] args)
 9     {
10         while (true)
11         {
12             Scanner scanner = new Scanner(System.in);
13             System.out.println("请输入一个十进制数");
14             int a = scanner.nextInt();
15             String b1 = Integer.toBinaryString(a);
16             System.out.println("十进制转换为二进制为:"+b1);
17             String b2 = Integer.toHexString(a);
18             System.out.println("十进制转换为十六进制为:"+b2);
19             String b3 = Integer.toOctalString(a);
20             System.out.println("十进制转换为八进制为:"+b3);
21         }
22                 
23     }
24 
25 }

实现输入字符的加密和解密。

 1 package com.wisezone.Test11;
 2 
 3 import java.util.Scanner;
 4 
 5 //实例004        实现输入字符的加密和解密。
 6 public class Encryption
 7 {
 8     
 9     public static void main(String[] args)
10     {
11         while (true)
12         {
13             Scanner scanner = new Scanner(System.in);//创建扫描器
14             System.out.println("请输入一个字符串或解密字符串");
15             String password = scanner.nextLine();//获取用户输入
16             char[] arr = password.toCharArray();//获取字符数组
17             for (int i = 0;i < arr.length;i++)//遍历字符数组
18             {
19                 arr[i] = (char)(arr[i] ^ 2000);//对每个数组元素进行异或运算
20             }
21             System.err.println(new String(arr));//输入密钥
22             System.out.println("加密或解密结果如下");
23         }
24         
25     }
26 }

判断一个数字的奇偶性。

 1 package com.wisezone.Test11;
 2 
 3 import java.util.Scanner;
 4 
 5 //实例003        判断一个数字的奇偶性。
 6 public class EvenOdd
 7 {
 8     public static void main(String[] args)
 9     {
10         Scanner cc = new Scanner(System.in);//创建输入流扫描器
11         while (true)
12         {
13             System.out.println("请输入一个整数");
14             int a = cc.nextInt();//获取用户输入的整数
15             String ss = (a % 2 == 0)?"输入的是偶数":"输入的是奇数";
16             System.out.println(ss);
17         }
18         
19     }
20     
21 }

不借助第三方变量实现两个变量值的互换。

 1 package com.wisezone.Test11;
 2 
 3 import java.util.Scanner;
 4 //实例005        不借助第三方变量实现两个变量值的互换。
 5 public class ExchangeValue
 6 {
 7 
 8     public static void main(String[] args)
 9     {
10         while (true)
11         {
12             Scanner s = new Scanner(System.in);
13             System.out.println("输入变量a的值");
14             long a = s.nextLong();
15             System.out.println("输入变量b的值");
16             long b = s.nextLong();
17             System.out.print("a="+a+"\tb="+b);
18             System.out.print("\t 互换后为 \t");
19             a = a ^ b;
20             b = b ^ a;
21             a = a ^ b;
22             System.out.print("a="+a+"\tb="+b);
23         }
24         
25         
26     }
27 
28 }

输出子孙级目录或者文件的名称(绝对路径打出来)

 1 package com.wisezone.file.IO;
 2 
 3 import java.io.File;
 4 
 5 /*
 6  * 输出子孙级目录或者文件的名称(绝对路径打出来)
 7  * 1、listFiles()
 8  * 2、递归
 9  */
10 public class Demo05
11 {
12 
13     public static void main(String[] args)
14     {
15         String pathname = "E:/JAVA软件资料";
16         File file = new File(pathname);
17         print(file);
18     }
19     public static void print(File sre)
20     {
21         if (sre == null || !sre.exists())
22         {
23             return;
24         }
25         System.out.println(sre.getName());
26         if (sre.isDirectory())
27         {
28             for (File ss:sre.listFiles())
29             {
30                 print(ss);
31             }
32         }
33     }
34     
35     
36     
37 }

将C盘一个文本文件复制到D盘。

 1 package com.wisezone.file.test;
 2 
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 //将C盘一个文本文件复制到D盘。
 8 
 9 /*
10  *     复制的原理：
11  *     其实就是将C盘下的文件数据存储到D盘的一个文件中。
12  * 
13  * 步骤：
14  *    1，在D盘创建一个文件。用于存储C盘文件中的数据。
15  *    2，定义读取流和C盘文件关联。
16  *    3，通过不断的读写完成数据存储。
17  *    4，关闭资源。
18  * 
19  */
20 public class CopyTest
21 {
22 
23     public static void main(String[] args) throws IOException
24     {
25         //copy1();
26         copy2();
27 
28     }
29 
30     //第二种方法
31     public static void copy2()
32     {
33         FileWriter fw = null;
34         FileReader fr = null;
35         
36         try
37         {
38             fw = new FileWriter("E:\\workspace\\新建文件夹\\hello.java");
39             fr = new FileReader("E:\\workspace\\新建文件夹\\Test6.java");
40             
41             char[] buf = new char[1024];
42             
43             int len = 0;
44             while ((len = fr.read(buf)) != -1)
45             {
46                 fw.write(buf,0,len);
47             }
48             
49         } catch (IOException e)
50         {
51             throw new RuntimeException("读写失败");
52         }
53         finally
54         {
55             try
56             {
57                 if (fr != null)
58                 {
59                     fr.close();
60                 }
61             } catch (IOException e2)
62             {
63                 
64             }
65             try
66             {
67                 if (fw != null)
68                 {
69                     fw.close();
70                 }
71             } catch (IOException e2)
72             {
73                 
74             }
75         }
76     }
77     
78     //第一种方法
79     //从C盘读一个字符，就往D盘写一个字符。
80     public static void copy1() throws IOException
81     {
82         //创建目的地。
83         FileWriter fw = new FileWriter("E:\\workspace\\新建文件夹.java\\B.java");
84         
85         //与已有文件关联。
86         FileReader fr = new FileReader("E:\\workspace\\新建文件夹.java\\A.java");
87         
88         int ch = 0;
89         while ((ch = fr.read())!= -1)
90         {
91             fw.write(ch);
92         }
93         fw.close();
94         fr.close();
95         
96     }
97 }

读取一个.java文件，并打印在控制台上。

 1 package com.wisezone.file.test;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.FileReader;
 5 import java.io.IOException;
 6 
 7 //读取一个.java文件，并打印在控制台上。
 8 public class FileReaderTest
 9 {
10 
11     public static void main(String[] args) throws IOException
12     {
13         FileReader fr = new FileReader("E:\\workspace\\新建文件夹.java\\A.java");
14 
15         char[] bug = new char[1024];
16         
17         int num = 0;
18         while ((num = fr.read(bug)) != -1)
19         {
20             System.out.print(new String(bug,0,num));
21         }
22         
23         fr.close();
24     }
25 
26 }

菲波那契数列

 1 package com.wisezone.test;
 2 
 3 public class FeiBoNaQie
 4 {
 5     /*菲波那契数列：0、1、1、2、3、5、8、13...。第一项为0，第二项为1，
 6     往后第N项为第（N-2）项+第（N-1）项之和，如第三项为：0+1=1，第四项为：1+1=2...。 
 7     输入一个正整数N求出前N项数列。 
 8     定义2个变量，分别保存n-2,n-1的值，通过(n-2 )+ (n-1)，可以得到N
 9     每次输出N的值
10     如N=5，显示：0 1 1 2 3  N=10，显示：0 1 1 2 3 5 8 13 21 34 */
11     
12     public static void PrintFo(int n){
13         int a = 0;
14         int b = 1;
15         System.out.print(a+",");
16         System.out.print(b+",");
17 
18         for(int i = 2;i < n;i++){
19             int c = a+b;
20             System.out.print(c+",");
21             a = b;
22             b = c;
23         }
24     }
25     
26     /*这个数列是由13世纪意大利斐波那契提出的,故叫斐波那契数列
27     1、  1、  2、  3、  5、  8、  13、  21
28     A  b  a+b
29     a  b  a+b….数列，问将这个数列中所有数相加大于等于5000,数列中最后一个数是多少？*/
30     public static int calcFo(int m)
31     {
32         int x = 0;
33         
34         int a = 0;
35         int b = 1;
36         
37         int sum = a + b;
38         while (sum < m)
39         {
40             int c = a + b;
41             sum += c;
42             System.out.println("c=" + c + ";sum=" + sum);//这行是把所有数全部打印出来了。
43             a = b ;
44             b = c;
45             
46             x = c;
47         }
48         return x;
49     }
50     public static void main(String[] args)
51     {
52         PrintFo(10);
53         //System.out.println(calcFo(5000));
54         
55     }
56 
57 }

一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，
求它在第10次落地时，共经过多少米？第10次反弹多高？

 1 package com.wisezone.test;
 2 
 3 public class HouZiChiTao
 4 {
 5     /*一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，
 6     求它在第10次落地时，共经过多少米？第10次反弹多高？ */
 7     public static void sphere()
 8     {
 9         double h = 100;
10         double s = 100;
11         for (int i = 1;i < 10;i++)
12         {
13             s += h;
14             h /= 2;
15         }
16         
17         System.out.println("共经过：" + s + "米");
18         System.out.println("反弹高度：" + h / 2 + "米");
19         
20     }
21     
22     /*猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个
23     第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。
24     到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少?*/
25     public static void peach()
26     {
27         int a = 1;
28         for (int i = 2; i <= 10; i++)
29         {
30             a = (a + 1) * 2;
31         }
32         System.out.println("第一天共摘了=" + a);
33     }
34     public static void main(String[] args)
35     {
36         //sphere();
37         peach();
38     }
39 
40 }

利用递归求5 的阶乘

 1 package com.wisezone.test;
 2 
 3 public class JieCheng
 4 {
 5     //利用递归求5 的阶乘
 6     public static int jiecheng(int a)
 7     {
 8         if (a == 1)
 9         {
10             return 1;
11         }
12         else
13         {
14             return a *jiecheng(a-1);
15         }
16         
17     }
18     
19     /*有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。
20     问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。
21     请问第五个人多大？*/
22     public static void age()
23     {
24         int age =10;
25         for (int i = 2; i <= 5;i++)
26         {
27             age = age + 2;
28         }
29         System.out.println(age);
30     }
31     public static void main(String[] args)
32     {
33         age();
34         //System.out.println(jiecheng(5));
35     }
36 
37 }

九九乘法表

 1 package com.wisezone.test;
 2 
 3 public class QiuQiuChengFa
 4 {
 5 
 6     public static void main(String[] args)
 7     {
 8     /*  1*1=1 
 9         1*2=2 2*2=4 
10         1*3=3 2*3=6 3*3=9 
11         1*4=4 2*4=8 3*4=12 4*4=16 
12         1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
13         1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
14         1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
15         1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
16         1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81*/
17         
18         for (int a = 1;a <= 9;a++)
19         {
20             for (int b = 1;b <= a;b++)
21             {
22                 System.out.print(b + "*" + a + "=" + b * a + "\t");
23             }
24             System.out.println();
25         }
26         
27         System.out.println("--------------------------------------------");
28         
29         //输入三个整数x,y,z，请把这三个数由小到大输出。  
30         //程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，
31         //如果x>y则将x与y的值进行交换，然后再用x与z进行比较，如果x>z则将x与z的值进行交换，这样能使x最小。  
32         
33         //打印出100-150之间的所有质数
34         int count = 0 ;
35         outher:for (int a = 100;a < 150;a++)
36         {
37             for (int b = 2; b < a / 2;b++)
38             {
39                 if (a % b == 0)
40                 {
41                     continue outher;
42                 }
43             }
44             System.out.print(a + " ");
45         }
46         
47     }
48 
49 }

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第3个月后每个月又生一对兔子，
假如兔子都不死，问每个月的兔子总数是多少？（20个月内）

 1 package com.wisezone.test;
 2 
 3 public class Rabbit
 4 {
 5 
 6     /*有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第3个月后每个月又生一对兔子，
 7     假如兔子都不死，问每个月的兔子总数是多少？（20个月内）*/
 8     public static void rabbit()
 9     {
10         System.out.println("第1个月兔子对数：1" );
11         System.out.println("第2个月兔子对数：1" );
12         int a = 1;
13         int b = 1;
14         int c;
15         int m = 12;
16         for (int i = 3; i <= m;i++)
17         {
18             c = b;
19             b += a;
20             a = c;
21             System.out.println("第" + i + "个月兔子的对数" + b);
22         }
23     }
24     
25     /*有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...
26     求出这个数列的前20项之和。 1.程序分析：请抓住分子与分母的变化规律。*/
27     public static double calcSum(int n)
28     {
29         int a = 2;
30         int b = 1;
31         int c;
32         double sum = 0;
33         for (int i = 1; i <= n ; i++)
34         {
35             sum = sum + (double)a / b;
36             c = b;
37             b = a ;
38             a = b + c;
39         }
40         return sum;
41     }
42     public static void main(String[] args)
43     {
44         rabbit();
45         /*int n = 20;
46         double s = calcSum(n);
47         System.out.println("前" + n + "项的和="+ s );*/
48     }
49 
50 }

打印出所有的 "水仙花数 "，所谓 "水仙花数 "是指一个三位数，其各位数字立方和等于该数本身。
例如：153是一个 "水仙花数 "，因为153=1的三次方＋5的三次方＋3的三次方。

 1 package com.wisezone.test;
 2 
 3 public class ShuiXianHua
 4 {
 5     /*打印出所有的 "水仙花数 "，所谓 "水仙花数 "是指一个三位数，其各位数字立方和等于该数本身。
 6     例如：153是一个 "水仙花数 "，因为153=1的三次方＋5的三次方＋3的三次方。*/
 7     public static void daffodil()
 8     {
 9         for (int i = 100; i < 1000; i++)
10         {
11             int c = i / 100;//百位
12             int b = (i-c*100)/10;//十位
13             int a = i % 10;//个位
14             if (a * a * a + b * b * b + c * c * c == i)
15             {
16                 System.out.println(i + "水仙花数");
17             }
18         }
19     }
20     public static void main(String[] args)
21     {
22         daffodil();
23         
24         
25     }
26 
27 }

测试生成随机6位大写字母

 1 package com.wisezone.test;
 2 
 3 public class SuiJi
 4 {
 5     public static void main(String[] args)
 6     {
 7         //测试生成随机6位大写字母
 8         String result = "";
 9         for (int i = 0; i < 6; i++)
10         {
11             int a = (int)(Math.random() * 26 +65);
12             result = result +(char) a;
13         }
14         System.out.println(result);
15     }
16 
17 }

 1 package com.wisezone.test;
 2 
 3 public class Test01 
 4 {
 5     // 定义一个方法，有两个整型参数，返回这两个参数的商并保留2位小数(保留小数点后的两位有效数字)
 6     public static double num(int a,int b)
 7     {    
 8         return Math.floor(a * 100.0 / b) / 100;
 9     }
10         
11     public static float num1(int a,int b)
12     {
13         return (float)Math.floor((double)(a*100.0f/b))/100;
14     }
15     // 定义一个方法，打印出九九乘法表
16     /*
17         1*1=1 
18         1*2=2 2*2=4 
19         1*3=3 2*3=6 3*3=9 
20         1*4=4 2*4=8 3*4=12 4*4=16 
21         1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
22         1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
23         1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
24         1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
25         1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
26     */
27     public static void jiu()
28     {
29         for(int i=1;i<=9;i++)
30         {
31             for(int j=1;j<=i;j++)
32             {
33                 System.out.print(j+"*"+i+"="+i*j+"\t");
34             }
35             System.out.println();
36         }
37     }
38     //定义一个方法，返回"AaBbCcDd...XxYyZz"
39     public static String test()
40     {
41         String a = "";
42         for(int b = 65;b <= 90; b++)
43         {
44             a += "" + (char)b + (char)(b + 32);
45         }
46             return a ;
47         }
48     // 定义一个方法，实现1000以内的正奇数相加并返回最终的结果
49         public static int nember()
50         {
51             int sum=0;
52             for(int i=1; i<1000; i=i+2)
53             {
54                 sum=sum+i;
55             }
56             return sum;    
57         }
58     // 定义一个方法，实现1000以内的正偶数相加并返回最终的结果
59     public static int name11()
60     {
61         int guest=0;
62         for(int x=2;x<=1000;x=x+2)
63         {
64             guest=guest+x;
65         }
66         return guest;
67     }
68     public static void main(String[] args) 
69     {
70         /*System.out.println(test());
71         jiu();
72         System.out.println("江苏省扬州市江都区");*/
73         num(10, 3);
74 
75     }
76 
77 }

 1 package com.wisezone.test;
 2 
 3 public class Test02
 4 {
 5     //定义一个方法，使用循环打印出26个英文小写字母所连接成的一个字符串，即"abcd...xyz"(提示：a字符的整数值为97，z字符的整数值为122)
 6     public static void sup()
 7     {
 8         for(int a=97;a<=122;a++)
 9         {
10             System.out.print((char)a);
11         }
12     }
13     //定义一个方法，判断两个输入的整型参数第一个参数是否能够被第二个参数所整除（考虑除数为0的情况，除数为0返回false）
14     public static boolean isTrue(int i,int j)
15     {
16         return j!=0&&i%j==0;
17         /*if(j==0)
18         {
19             return false;
20         }
21         else if(i%j==0)
22         {
23             return true;
24         }
25         else 
26         {
27             return false;
28         }*/
29     }
30     // 定义一个方法，该方法有两个int型参数a和b，在方法中交换a和b的值，在交换前分别打印a和b的值，交换之后再分别打印a和b的值
31     public static void swap(int a,int b)
32     {
33         System.out.println(a);
34         System.out.println(b);
35         int c=a;
36         a=b;
37         b=c;
38         System.out.println(a);
39         System.out.println(b);
40     }
41     public static void main(String[] args) 
42     {
43         
44     }
45 
46 }

 1 package com.wisezone.test;
 2 
 3 public class Test05
 4 {
 5     /*求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。
 6     例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。  */
 7     public static void main(String[] args)
 8     {
 9         int a = 2;
10         int n = 5;
11         int s = 0;
12         int sum = 0;
13         for (int i = 0; i < n; i++)
14         {
15             s = s * 10 + a;
16             sum += s;
17             System.out.print(s);
18             if (i < n -1)
19             {
20                 System.out.print("+");
21             }
22         }
23         System.out.println("=" + sum);
24     }
25 
26 }

 1 package com.wisezone.test;
 2 
 3 public class Test06
 4 {
 5     public static void main(String[] args)
 6     {
 7         //求出所有的5位数的回文数，显示在屏幕上。即12321是回文数，个位与万位相同，十位与千位相同。  
 8         for (int b = 10000; b <= 99999; b++)
 9         {
10                 
11         }
12             
13             
14             
15             
16         //编一个程序, 求 s=1!+2!+3!+…..+n!, (n由输入决定, 多重循环)
17         int n = 5;
18         int factor = 1;
19         int sum = 3;
20         for (int i = 1; i <= n;i++)
21         {
22             factor *= i;
23             sum += factor;
24         }
25         System.out.println(sum);
26         
27         //百钱买百鸡(多重循环) 
28         //一只公鸡值５元，一只母鸡值３元，３只小鸡值１元，现用一百元要买一百只鸡，问有什么方案？（答案：四种方案）
29         int x,y,z;
30         for (x = 0; x <= 20; x++)
31         {
32             for (y = 0; y <= 33; y++)
33             {
34                 z = 100-x-y;
35                 if (5 * x + 3 * y + z / 3.0 == 100)
36                 {
37                     System.out.println("公鸡=" +x +"母鸡=" +y + "小鸡=" +z);
38                 }
39             }
40         }
41         //把一元钞票换成一分、二分、五分硬币（每种至少一枚），有哪些种换法？ 答案：461种  
42         int q,w,c;
43         int count = 0;
44         for (q = 1; q <= 100; q++)
45         {
46             for (w = 1; w <= 50; w++)
47             {
48                 for (c = 1; c <= 20; c++)
49                 {
50                     if (q * 1 + c * 5 + w * 2 ==100)
51                     {
52                         System.out.println("1分硬币=" + q + ";2分硬币=" + w + ";5分硬币" + c);
53                         count += 1;
54                     }
55                 }
56             }
57         }
58         System.out.println(count);
59     }
60         
61 
62 }

 1 package com.wisezone.test;
 2 
 3 public class Test07
 4 {
 5 
 6     public static void main(String[] args)
 7     {
 8         //求1到100的和
 9         //用for循环来写的
10         int a = 0;
11         for (int i = 1; i <= 100; i++)
12         {
13             a += i;
14         }
15         System.out.println(a);
16         
17         //求1到100的和
18         //用while循环来写的
19         int b = 1;
20         int sum = 0;
21         while (b <= 100)
22         {
23             sum += b;
24             b++;
25         }
26         System.out.println("sum和为：" + sum);
27                 
28                 
29         //编一个程序，求出所有各位数字的立方和等于1099的3位整数。(求立方=a*a*a)  
30         for (int n = 100; n <= 999 ;n++)
31         {
32             int h = n / 100;  //百位
33             int t = n % 100 / 10;  //十位
34             int s = n % 10;  //个位
35             if (h * h * h + t * t * t + s * s * s == 1099)
36             {
37                 System.out.println(n);
38             }
39         }
40 
41     }
42 
43 }

 1 package com.wisezone.test;
 2 
 3 public class Test08 
 4 {
 5     // 定义一个方法，实现从1加到1000并返回最终的结果
 6     public static int name()
 7     {
 8         int sum=0;
 9         for(int i=1;i<=1000;i++)
10         {
11             sum+=i;//0+1+2+3+...+1000
12         }
13         return sum;
14     }
15     //定义一个方法，用来打印从100到1的数字，每个数字打印一行
16     public static void sum ()
17     {
18         for(int i=100;i>=1;i--)
19         {
20             System.out.println(i);
21         }
22     }
23     //定义一个方法，该方法有一个整型输入参数n，返回n*3+n*6+n*9+n*12+...+n*300的值
24     public static int my(int n)
25     {
26         int sum=0;
27         for(int i=1;i<=100;i++)
28         {
29             sum+=i;
30         }
31         return 3*n*sum;
32     }
33     public static void main(String[] args) 
34     {
35         
36 
37     }
38 
39 }

 1 package com.wisezone.test;
 2 
 3 public class Test111
 4 {
 5     //随机生成一个不多于5位（ 100000以内）的正整数，求出它是几位数？二、逆序打印出各位数字。
 6     public static void num()
 7     {
 8         int a = (int)(Math.random()*100000);
 9         System.out.println(a);
10         String str=a+"";
11         char[] ch=str.toCharArray();
12         for(int i=0;i<=str.length()/2;i++)
13         {
14             char temp=ch[i];
15             ch[i]=ch[str.length()-i-1];
16             ch[str.length()-i-1]=temp;
17         }
18         str=new String(ch);//将字符数组转为字符串
19         System.out.println(a+"是一个"+str.length()+"位数\n逆序输出为:\t"+str);
20         
21     }
22     public static void main(String[] args)
23     {
24         num();
25     }
26 }

一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。
例如6=1＋2＋3.编程找出1000以内的所有完数。

 1 package com.wisezone.test;
 2 
 3 public class WanShu
 4 {
 5     /* */
 6     public static void sum()
 7     {
 8         int a = 0;
 9         System.out.println("1000以内的所有完数有：");
10         for (int i = 1;i < 1000;i++)
11         {
12             a = 0;
13             for (int j = 1;j <= i / 2;j++)
14             {
15                 if (i % j == 0)
16                 {
17                     a += j;
18                 }
19             }
20             if (a == i)
21             {
22                 System.out.print(a + "\t");
23             }
24         }
25     }
26     public static void main(String[] args)
27     {
28         sum();
29         
30     }
31 
32 }

 1 package com.wisezone.test;
 2 
 3 public class ZhiShu
 4 {
 5     /*将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。   
 6     程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：   
 7     (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。   
 8     (2)如果n <> k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。   
 9     (3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。*/
10     public static void sum(int n)
11     {
12         int k = 2;
13         System.out.print(n + "=");
14         while (k <= n)
15         {
16             if (k == n)
17             {
18                 System.out.println(n);
19                 break;
20             }
21             else if (n % k == 0)
22             {
23                 System.out.print(k + "*" );
24                 n = n / k;
25             }
26             else
27             {
28                 k++;
29             }
30             
31         }
32     }
33     public static void main(String[] args)
34     {
35         sum(90);
36     }
37 
38 }

 1 package com.wisezone.test;
 2 
 3 public class ZiMu02
 4 {
 5     //定义一个方法，返回"AaBbCcDd...XxYyZz"
 6     public static String sum()
 7     {
 8         String sum ="";
 9         for (int i = 65; i <= 90; i++)
10         {
11             int b = 32 + i;
12             sum += "" + (char)i + (char)b;
13         }
14         return sum;
15     }
16     
17     //定义一个方法，返回"AbCdEf...Yz"
18     public static String sun()
19     {
20         String sun = "";
21         for (int a = 1; a <= 26; a++)
22         {
23             if (a % 2 == 1)
24             {
25                 sun += "" + (char)(64 + a);
26             } 
27             else
28             {
29                 sun += "" + (char)(96 + a);
30             }
31         }
32         return sun;
33     }
34 
35     public static void main(String[] args)
36     {
37         System.out.println(sum());
38         System.out.println(sun());
39     }
40 }

题目：古典问题：有一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔子长到第三个月后每个月
又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

 1 package com.wisezone.test02;
 2 /*题目：古典问题：有一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔子长到第三个月后每个月
 3 又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？*/
 4 public class lianxi01
 5 {
 6     
 7     // 这是一个菲波拉契数列问题
 8     public static void main(String[] args)
 9     {
10         System.out.println("第 1 个月的兔子对数 : 1");
11         System.out.println("第 2 个月的兔子对数 : 1");
12         int f1 = 1, f2 = 1, f, M = 24;
13         for (int i = 3; i <= M; i++)
14         {
15             f = f2;
16             f2 = f1 + f2;
17             f1 = f;
18             System.out.println("第 " + i + "个月的兔子对数 : " + f2);
19         }
20         
21     }
22 }

 1 package com.wisezone.test02;
 2 
 3 /*题目：判断 101-200 之间有多少个素数，并输出所有素数。
 4 程序分析：判断素数的方法：用一个数分别去除 2 到 sqrt(这个数)，如果能被整除， 则表明
 5 此数不是素数，反之是素数。*/
 6 public class lianxi02
 7 {
 8     public static void main(String[] args)
 9     {
10         int count = 0;
11         for (int i = 101; i < 200; i += 2)
12         {
13             boolean b = false;
14             for (int j = 2; j <= Math.sqrt(i); j++)
15             {
16                 if (i % j == 0)
17                 {
18                     b = false;
19                     break;
20                 } else
21                 {
22                     b = true;
23                 }
24             }
25             if (b == true)
26             {
27                 count++;
28                 System.out.println(i);
29             }
30         }
31         System.out.println(" 素数个数是 : " + count);
32     }
33 }

 1 package com.wisezone.test02;
 2 
 3 /*题目：打印出所有的 " 水仙花数 " ，所谓 " 水仙花数 " 是指一个三位数，其各位数字立方和
 4 等于该数本身。例如：153 是一个 " 水仙花数 " ，因为 153=1 的三次方＋5 的三次方＋3 的
 5 三次方。*/
 6 public class lianxi03
 7 {
 8     public static void main(String[] args)
 9     {
10         int b1, b2, b3;
11         for (int m = 101; m < 1000; m++)
12         {
13             b3 = m / 100;
14             b2 = m % 100 / 10;
15             b1 = m % 10;
16             if ((b3 * b3 * b3 + b2 * b2 * b2 + b1 * b1 * b1) == m)
17             {
18                 System.out.println(m + "是一个水仙花数");
19             }
20         }
21     }
22 }

 1 package com.wisezone.test02;
 2 
 3 /*题目：将一个正整数分解质因数。例如：输入 90,打印出 90=2*3*3*5。
 4 程序分析：对 n 进行分解质因数，应先找到一个最小的质数 k，然后按下述步骤完成：
 5 (1)如果这个质数恰等于 n，则说明分解质因数的过程已经结束，打印出即可。
 6 (2)如果 n <> k，但 n 能被 k 整除，则应打印出 k 的值，并用 n 除以 k 的商,作为新的正整数
 7 你 n,重复执行第一步。
 8 (3)如果 n 不能被 k 整除，则用 k+1 作为 k 的值,重复执行第一步。*/
 9 import java.util.*;
10 
11 public class lianxi04
12 {
13     public static void main(String[] args)
14     {
15         Scanner s = new Scanner(System.in);
16         System.out.print(" 请键入一个正整数 : ");
17         int n = s.nextInt();
18         int k = 2;
19         System.out.print(n + "=");
20         while (k <= n)
21         {
22             if (k == n)
23             {
24                 System.out.println(n);
25                 break;
26             } else if (n % k == 0)
27             {
28                 System.out.print(k + "*");
29                 n = n / k;
30             } else
31                 k++;
32         }
33     }
34 }

 1 package com.wisezone.test02;
 2 
 3 import java.util.*;
 4 /**
 5  * 题目：输入两个正整数 m 和 n，求其最大公约数和最小公倍数。
 6 /**在循环中，只要除数不等于 0，用较大数除以较小的数，将小的一个数作为下一轮循环的
 7 大数，取得的余数作为下一轮循环的较小的数，如此循环直到较小的数的值为 0，返回较大
 8 的数，此数即为最大公约数，最小公倍数为两数之积除以最大公约数。* /
 9  * @author 王东海
10  * @2017年3月21日
11  */
12 public class lianxi06
13 {
14     public static void main(String[] args)
15     {
16         int a, b, m;
17         Scanner s = new Scanner(System.in);
18         System.out.print(" 键入一个整数： ");
19         a = s.nextInt();
20         System.out.print(" 再键入一个整数： ");
21         b = s.nextInt();
22         deff cd = new deff();
23         m = cd.deff(a, b);
24         int n = a * b / m;
25         System.out.println("最大公约数 : " + m);
26         System.out.println("最小公倍数 : " + n);
27     }
28 }
29 
30 class deff
31 {
32     public int deff(int x, int y)
33     {
34         int t;
35         if (x < y)
36         {
37             t = x;
38             x = y;
39             y = t;
40         }
41         while (y != 0)
42         {
43             if (x == y)
44                 return x;
45             else
46             {
47                 int k = x % y;
48                 x = y;
49                 y = k;
50             }
51         }
52         return x;
53     }
54 }

 1 package com.wisezone.test02;
 2 
 3 import java.util.Scanner;
 4  /*
 5   * 题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
 6 分析：这题也比较简单，知道怎么表示字母、空格、数字就OK
 7   */
 8 public class Statistic {
 9     public static void main(String[] args)
10     {
11         Scanner in = new Scanner(System.in);
12          
13         System.out.println("请输入一行字符：");
14         String s = in.nextLine();
15          
16         int letter = 0, symbol = 0, space = 0, number = 0;
17         char[] strArray = s.toCharArray();
18         for (int i = 0; i < strArray.length; i++)
19         {
20             char c =  strArray[i];
21             if((‘a‘ <= c && c <= ‘z‘) || (‘A‘ <= c && c  <= ‘Z‘))
22                 letter++;
23             else if(48 <= c  && c <= 57)      //注意！数字0-9的ASCII码是48-57
24                 number++;
25             else if(c == ‘ ‘)
26                 space++;
27             else
28                 symbol++;
29         }
30         System.out.println("这个句子有 " + letter + " 个字母, ");
31         System.out.println("还有"+ number + " 个数字, ");
32         System.out.println("还有 " + space + " 个空格, " + "和 " + symbol + " 个符号.");
33     }
34 }

  1 package com.wisezone.array;
  2 
  3 public class Test2
  4 {
  5     //1、小明每天攒2.5元，每隔4天要花去6元，请问需要多少天小明才可以攒够100元？
  6     public static void test()
  7     {
  8         double a = 0.0;
  9         int b = 0;
 10         while(a <= 100)
 11         {
 12             b++;
 13             a += 2.5;
 14             if(b%5==0)
 15             {
 16                 a -= 6;
 17             }
 18         }
 19         System.out.println("攒够100元需要"+b+"天");
 20     }
 21     
 22     //2、对于任意给定的一个int数组，请定义几个方法分别求出数组的最大值、最小值、总和和平均值
 23     //最大值
 24     public static int max(int[] arr)
 25     {
 26         if(arr == null || arr.length == 0){
 27             return 0;
 28         }
 29         int max=arr[0];
 30         int len = arr.length;
 31         for (int i = 1; i < len; i++)
 32         {
 33             if(max<arr[i])
 34             {
 35                 max=arr[i];
 36             }
 37         }
 38         return max;
 39     }
 40 
 41     //最小值
 42     public static int min(int[] arr)
 43     {
 44         if(arr == null || arr.length == 0){
 45             return 0;
 46         }
 47         int min=arr[0];
 48         int len = arr.length;
 49         for (int i = 1; i < len; i++)
 50         {
 51             if(min>arr[i])
 52             {
 53                 min=arr[i];
 54             }
 55         }
 56         return min;
 57     }
 58 
 59     //总和
 60     public static int sum(int[] arr)
 61     {
 62         if(arr == null || arr.length == 0){
 63             return 0;
 64         }
 65         /*int sum=arr[0];
 66         int len = arr.length;
 67         for (int i = 1; i < len; i++)
 68         {  
 69             sum+=arr[i];
 70         }*/
 71         int sum = 0;
 72         for (int i : arr)
 73         {
 74             sum += i;
 75         }
 76         return sum;
 77     }
 78 
 79     //平均值
 80     public static double qwe(int[] arr)
 81     {
 82         /*if(arr == null || arr.length == 0)
 83         {
 84             return 0;
 85         }
 86         int sum=0;
 87         for (int i : arr)
 88         {
 89             sum += i;
 90         }*/
 91         return sum(arr)*1.0/arr.length;
 92     }    
 93 
 94     //3、定义一个方法，将给定的两个int数组拼成一个数组并返回
 95     public static int[] connect(int[] arr1,int[] arr2)
 96     {
 97         int len1 = arr1.length,len2 = arr2.length;
 98         int[] arrcon=new int[len1+len2];
 99         for(int i=0;i<len1;i++)
100         {
101             arrcon[i]=arr1[i];
102         }
103         for(int j=0;j<len2;j++)
104         {
105             arrcon[j+len1]=arr2[j];
106         }
107         return arrcon;
108     }
109     
110     //4、定义一个方法，判断一个给定的int数组中是否包含一个给定的值
111     public static boolean cum(int[] arr3,int a)
112     {
113         if(arr3 == null || arr3.length == 0)
114         {
115             return false;
116         }
117 
118         for (int i : arr3)
119         {
120             if(i==a)
121             {
122                 return true;
123             }
124         }
125 
126         return false;
127     }
128     
129     //5、定义一个方法，将一个给定的字符串数组按照给定的分隔符（比如以逗号、空格、分号等对数组的每一个元素分隔后拼接）拼接起来并返回
130     public static String result(String[] arr4 ,char a)
131     {
132         int len = arr4.length;
133         if(arr4==null||len==0)
134         {
135             return "";
136         }
137         String i="";
138         for(int b=0;b<len;b++)
139         {
140             if(b==0)
141             {
142                 i+=arr4[b];
143             }
144             else
145             {
146                 i+=a+arr4[b];
147             }
148 
149             /*if(b == len-1)
150             {
151                 i+=arr4[b];
152             }
153             else
154             {
155                 i+=arr4[b]+a;
156             }*/
157         }
158         return i;
159     }
160     
161     //6、定义一个方法，将一个给定的字符数组拼接成一个字符串返回
162     public static String num(char[] arr)
163     {
164         String i="";
165         for(char n : arr)
166         {
167             i+=n;
168         }
169         return i;
170     }
171     
172     //7、定义一个方法，将一个给定的数组的元素反转过来并返回，比如对于数组{1,2,3,4,5}返回{5,4,3,2,1} {1,2,3,4} {4,3,2,1}
173     public static int[] method1(int[] arr1)
174     {
175         int temp;//第三方变量
176         for(int i =0;i < arr1.length/2;i++){
177             temp = arr1[i];
178             arr1[i] = arr1[arr1.length-1-i];
179             arr1[arr1.length-1-i]=temp;
180         }
181         return arr1;
182     }
183     
184     public static void main(String[] args)
185     {
186         /*System.out.println(min(new int[]{3,2,1}));
187         int[] result = connect(new int[]{23,34,45,67}, new int[]{78,89,90});
188         for (int i : result)
189         {
190             System.out.println(i);
191         }
192         
193         System.out.println(result(new String[]{"hello","world"}, ‘;‘));
194         
195         System.out.println(num(new char[]{‘a‘,‘b‘,‘c‘}));*/
196         
197         int[] re = method1(new int[]{1,2,4,6,9,8,7});//{1,2,3,4,5}
198         for (int i : re)
199         {
200             System.out.print(i);
201         }
202         /*System.out.println();
203         System.out.println(3 & 2);//2 按位且
204         System.out.println(3 | 2);//3 按位或
205         //^
206         System.out.println(3 ^ 2);//按位异或
207 */    }
208 }

  1 package com.wisezone.array;
  2 
  3 import java.util.Arrays;
  4 
  5 public class Test3
  6 {
  7     //定义一个方法，实现对给定的两个数组判断是否相等（即数组元素是否完全相同，对应索引处的元素值相同）
  8     public static boolean isTrue(int[] arr1,int[] arr2)
  9     {
 10         int len1=arr1.length;
 11         int len2=arr2.length;
 12         if(len1!=len2)
 13         {
 14             return false;
 15         }
 16         
 17         for(int i=0;i<len1;i++)
 18         {
 19             if(arr1[i]!=arr2[i])
 20             {
 21                 return false;
 22             }
 23         }
 24         
 25         return true;
 26     }
 27     //定义一个方法，实现删除给定的一个数组中的某个元素值
 28     public static int[] test(int[] arr,int a)
 29     {
 30         int len = arr.length;
 31         int[] arr1=new int[len-1];
 32         int x=0;
 33         for(int i=0;i<len;i++)
 34         {
 35             if (arr[i]==a)
 36             {
 37                 continue;
 38             }
 39             arr1[x++]=arr[i];
 40         }
 41         return arr1;
 42     }
 43     
 44     //定义一个方法，实现向给定的一个数组中在指定索引处添加一个给定的元素
 45     public static int[] addele(int[] arr,int a,int ele)
 46     {
 47         int[] narr= new int[arr.length+1];
 48         for(int i=0;i<arr.length+1;i++)
 49         {
 50             if(i<a)
 51             {
 52                 narr[i]=arr[i];
 53             }
 54             else if(i==a)
 55             {
 56                 narr[i]=ele;
 57             }
 58             else
 59             {
 60                 narr[i]=arr[i-1];
 61             }
 62         }
 63         System.out.println(Arrays.toString(narr));
 64         return narr;
 65     }
 66     //定义一个方法，实现替换一个给定的数组中指定索引处的元素值{1,2,3} 1（索引） 4（新值） {1,4,3}
 67     public static int[] pl(int[] arr,int n,int b)
 68     {
 69         if(arr == null || arr.length == 0)
 70         {
 71             return new int[]{};
 72         }
 73         
 74         if(n < 0 || n > arr.length - 1)
 75         {
 76             throw new ArrayIndexOutOfBoundsException(n);
 77         }
 78         
 79         arr[n]=b;
 80         return arr;
 81     }
 82     //定义一个方法，实现替换一个给定的数组中与给定的元素值相同的元素{1,3,2,3} 3（要替换的值） 4（新值） {1,4,2,4}
 83     public static int[] num(int[] arr,int a,int b)
 84     {
 85         for(int i=0;i<arr.length;i++)
 86         {
 87             if(arr[i]==a)
 88             {
 89                 arr[i]=b;
 90             }
 91         }
 92         
 93         return arr;
 94     }
 95     //定义一个方法，实现对给定的数组元素进行打乱并返回
 96     public static int[] shuffle(int[] arr)
 97     {
 98         int len = arr.length;
 99         int temp,index;
100         for (int i = 0; i < len; i++)
101         {
102             temp = arr[i];
103             index = (int) (Math.random()*len);
104             arr[i] = arr[index];
105             arr[index] = temp;
106         }
107         
108         return arr;
109     }
110     
111     //定义一个方法，找出数组中最接近平均值的元素的索引
112     public static int method(int[] arr)
113     {
114         int sum = 0 ;
115         double avg;
116         int a = 0;
117         for (int i = 0; i < arr.length; i++)
118         {
119             sum += arr[i];
120         }
121         avg = sum*1.0/arr.length;
122         for (int i = 1; i < arr.length; i++)
123         {
124             if (Math.abs(arr[a]-avg) > Math.abs(arr[i]-avg))
125             {
126                 a = i;
127             }
128         }
129         System.out.println("最接近平均值的数组元素索引为"+a);
130         return a;
131     }
132     
133     public static void main(String[] args)
134     {
135         Math.random();//0.0-1.0
136         for (int i = 0; i < 100; i++)
137         {
138             System.out.println((int)(Math.random()*10));
139         }
140         
141         String text = "hello world";
142         char[] chars = text.toCharArray();
143         for (char c : chars)
144         {
145             System.out.println("" + c);
146         }
147         
148         System.out.println("====");
149         addele(new int[]{1,2,3,4,5,6}, 3, 99);
150         isTrue(new int[]{1,2,3},new int[]{1,2,3});
151         
152         System.out.println("------------------");
153         
154         for (int i = 0; i < 10; i++)
155         {
156             System.out.println(Arrays.toString(shuffle(new int[]{1,2,3,4})));
157         }
158         
159         System.out.println(method(new int[]{5,4,3,2}));
160     }
161 }

  1 package com.wisezone.array;
  2 
  3 public class Test4
  4 {
  5     //定义一个方法，实现从52张牌中随机抽出13张牌
  6     public static void shuffleCards()
  7     {
  8         String[] cards = new String[52];
  9         String[] a = {"黑桃","红桃","方块","梅花"};
 10         String[] b = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
 11         int count = 0;
 12         for (int i = 0; i < 4; i++)
 13         {
 14             for (int j = 0; j < 13; j++)
 15             {
 16                 cards[count++]=a[i]+b[j];
 17             }
 18         }
 19         int c;
 20         String d;
 21         for(int i = 0;i < 52;i++)
 22         {
 23             c = (int)(Math.random()*52);
 24             d = cards[i];
 25             cards[i] = cards[c];
 26             cards[c] = d;
 27         }
 28         
 29         for (int i = 0;i < 13;i++)
 30         {
 31             System.out.println(cards[i]);
 32         }
 33         //System.out.println(Arrays.toString(cards));
 34     }
 35     public static void sum()
 36     {
 37         int[] arr = new int[52];
 38         String[] a = {"黑桃","红桃","方块","梅花"};
 39         String[] b = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
 40         for(int i = 0;i < 52;i++)
 41         {
 42             arr[i] = i;
 43         }
 44         int c,d;
 45         for(int i = 0;i < 52;i++)
 46         {
 47             c = (int)(Math.random()*52);
 48             d = arr[i];
 49             arr[i] = arr[c];
 50             arr[c] = d;
 51         }
 52         for(int i = 0;i < 13;i++)
 53         {
 54             String aa = a[arr[i]%4];
 55             String bb = b[arr[i]%13];
 56             System.out.println(aa + bb);
 57         }
 58     }
 59     //定义一个方法，实现对给定的一个字符串统计26个英文字母每个字母出现的次数
 60     public static void sum2(String str)
 61     {
 62         char[] chars= str.toCharArray();
 63         //"hello" {‘h‘,‘e‘,‘l‘,‘l‘,‘o‘}
 64         int[] num=new int[26];
 65         char temp;
 66         for(int i=0;i<chars.length;i++)
 67         {
 68             temp = chars[i];
 69             if (temp >= ‘a‘ && temp <= ‘z‘)
 70             {
 71                 num[temp-‘a‘]++;
 72             }
 73             
 74             if (temp >= ‘A‘ && temp <= ‘Z‘)
 75             {
 76                 num[temp-‘A‘]++;
 77             }
 78         }
 79         
 80         for(int j=0;j<26;j++)
 81         {
 82             if (num[j] > 0)
 83             {
 84                 System.out.println((char)(j+97) + "出现次数：" + num[j]);
 85             }
 86         }
 87     }
 88     //定义一个方法，找出数组中最接近平均值的元素
 89     public static int add(int[]arr)
 90     {
 91         int len=arr.length;
 92         double avg;
 93         int sum = 0;
 94         int a=0;
 95         for(int i = 0 ; i<len ; i++)
 96         {
 97             sum+=arr[i];
 98         }
 99         avg=sum*1.0/len;
100         for(int i = 1 ; i<len ; i++)
101         {
102             if(Math.abs(arr[a]-avg) > Math.abs(arr[i]-avg))
103             {
104                 //arr[a]=arr[i];
105                 a=i;
106             }
107         }
108         System.out.println("找出数组中最接近平均值的元素是"+arr[a]);
109         return arr[a];
110     }
111     //定义一个方法，判断一个给定的数组中是否包含全了0-9这10个数字
112     public static boolean judge(int[] arr)
113     {
114         if(arr == null || arr.length < 10)
115         {
116             return false;
117         }
118         
119         int[] temp = new int[10];
120         
121         int len = arr.length;
122         for(int i = 0; i < len; i++)
123         {
124             if(arr[i] >= 0 && arr[i] <= 9)
125             {
126                 temp[arr[i]]++;
127             }
128         }
129         
130         for (int i : temp)
131         {
132             if(i==0)
133             {
134                 return false;
135             }
136         }
137         
138         return true;
139     }
140     public static void main(String[] args)
141     {
142         //sum();
143         //shuffleCards();
144         sum2("hello world 1234 hello world @ $ HELLO WORLD");
145         //System.out.println((int)‘9‘);
146 //        System.out.println(judge(new int[]{1,2,3,4,5,6,7,8,9,10}));
147     }
148 }

  1 package com.wisezone.array;
  2 
  3 public class Test5
  4 {
  5     //定义一个方法，实现对给定的一个字符串统计0-9数字出现的次数（‘0‘字符的整型值为48，‘9‘字符的整型值为57）
  6     public static void mok(String sec)
  7     {
  8         if (sec == null || sec.length() == 0)
  9         {
 10             return;
 11         }
 12         
 13         char[] chars=sec.toCharArray();
 14         int[] arr=new int[10];
 15         int tmep;
 16         for(int a=0;a<chars.length;a++)
 17         {
 18             tmep=(int)chars[a];
 19             if(tmep>=48&&tmep<=57)
 20             {
 21                 arr[tmep-48]++;
 22             }
 23         }
 24         for(int b=0;b<arr.length;b++)
 25         {
 26             if(arr[b]!=0)
 27             {
 28                 System.out.println(b+"出现的次数："+arr[b]);
 29             }
 30         }
 31 
 32     }
 33     //定义一个方法，实现对给定的一个字符串统计大小写英文字母每个字母出现的次数（大小写分开统计）
 34     public static void sum5(String str)
 35     {
 36         if(str==null||str.length()==0)
 37         {
 38             return;
 39         }
 40         
 41         char[] chars=str.toCharArray();
 42         int[] toop=new int[52];
 43         char coop;
 44         for(int a=0;a<chars.length;a++)
 45         {
 46             coop=chars[a];
 47             if(coop >= ‘a‘ && coop<=‘z‘)
 48             {
 49                 toop[coop-‘a‘]++;
 50             }
 51             if(coop >= ‘A‘ && coop<=‘Z‘)
 52             {
 53                 toop[coop-‘A‘+26]++;
 54             }
 55         }
 56         for(int b=0;b<26;b++)
 57         {
 58             if(toop[b]>0)
 59             {
 60                 System.out.println((char)(b+97) + "小写字母出现的次数"+ toop[b]);
 61             }
 62         }
 63         for(int b=26;b<52;b++)
 64         {
 65             if(toop[b]>0)
 66             {
 67                 System.out.println((char)(b+65-26) + "大写字母出现的次数" +toop[b]);
 68             }
 69         }
 70     }
 71 
 72     //定义一个方法，实现对给定的一个字符串判断是否26个英文字母全部出现
 73     public static boolean isture(String sum)
 74     {
 75         if (sum == null || sum.length() < 26)
 76         {
 77             return false;
 78         }
 79         
 80         char[] arr=sum.toCharArray();
 81         int[] arr2=new int[26];
 82         
 83         for(int i = 0;i < arr.length;i++)
 84         {
 85             int temp=(int)arr[i];
 86             if (temp>=65&&temp<=90)
 87             {
 88                 arr2[temp-65]=1;
 89             }
 90             if (temp>=97&&temp<=122)
 91             {
 92                 arr2[temp-97]=1;
 93             }
 94         }
 95         for(int j=0;j<26;j++)
 96         {
 97             if (arr2[j]==0)
 98             {
 99                 return false;
100             }
101         }
102         return true;
103     }
104     
105     public static void main(String[] args)
106     {
107         mok("as1de2er9qw3hj6kk1ll9");
108         /*System.out.println(isture(null));
109         System.out.println(isture("hello"));
110         System.out.println(isture("abcdEFGHIJKlmnOPQRSTuvwxyz"));
111         System.out.println(isture("abcdEFGHIJKlnOPQRSTuvwxyz19645"));*/
112         //sum5("jfdajdlaDFJALDJLAJDLdalfjlajflJFALDJFLAJ7394173917");
113     }
114 }

  1 package com.wisezone.array;
  2 
  3 import java.util.Arrays;
  4 
  5 public class Test6
  6 {
  7     public static void main(String[] args)
  8     {
  9         // System.out.println(Arrays.toString(quChong(new int[] { 1, 2, 2, 3
 10         // })));
 11         // System.out.println(Arrays.toString(union(new int[]{1,2,2,4}, new
 12         // int[]{2,3,4})));
 13         intersect(new int[] { 1, 2, 2, 4 }, new int[] { 2, 3, 4 });
 14         differ(new int[] { 1, 2, 2, 4 }, new int[] { 2, 3, 4 });
 15         differ2(new int[] { 1, 2, 2, 4 }, new int[] { 2, 3, 4 });
 16     }
 17 
 18     // 定义一个方法，将给定的两个int数组拼成一个数组并返回
 19     public static int[] connect(int[] arr1, int[] arr2)
 20     {
 21         int len1 = arr1.length, len2 = arr2.length;
 22         int[] arrcon = new int[len1 + len2];
 23         for (int i = 0; i < len1; i++)
 24         {
 25             arrcon[i] = arr1[i];
 26         }
 27         for (int j = 0; j < len2; j++)
 28         {
 29             arrcon[j + len1] = arr2[j];
 30         }
 31         return arrcon;
 32     }
 33 
 34     // 定义一个方法，实现对给定的一个数组去除里面的重复元素并返回
 35     public static int[] quChong(int[] arr)
 36     {
 37         if (arr == null || arr.length == 0)
 38         {
 39             return null;
 40         }
 41         // 第一步：标记原来数组哪些索引处的值为重复的
 42         boolean[] arr1 = new boolean[arr.length];
 43         int count = 0;
 44         for (int i = 0; i < arr.length - 1; i++)
 45         {
 46             for (int j = i + 1; j < arr.length; j++)
 47             {
 48                 if (arr[i] == arr[j])
 49                 {
 50                     arr1[j] = true;
 51                     count++;
 52                 }
 53             }
 54         }
 55         // 第二步：计算出原来数组有多少个不重复的元素
 56         /*int count = 0;
 57         for (int i : arr1)
 58         {
 59             if (i == 0)
 60             {
 61                 count++;
 62             }
 63         }*/
 64         // 第三步：就是从原来数组中取出不重复的元素的值放入新的数组中并返回
 65         int[] result = new int[arr.length-count];
 66         int num = 0;
 67         for (int i = 0; i < arr1.length; i++)
 68         {
 69             if (!arr1[i])
 70             {
 71                 result[num++] = arr[i];
 72             }
 73         }
 74 
 75         return result;
 76     }
 77 
 78     // 定义三个方法，分别实现对给定的两个数组进行并交差运算并返回（其中差是第一个数组对第二个数组的差，即第一个数组不同于第二个数组的元素）
 79     public static int[] union(int[] arr1, int[] arr2)
 80     {
 81         int[] union = connect(arr1, arr2);
 82         return quChong(union);
 83     }
 84 
 85     // 定义一个方法，判断一个给定的int数组中是否包含一个给定的值
 86     public static boolean cum(int[] arr3, int a)
 87     {
 88         if (arr3 == null || arr3.length == 0)
 89         {
 90             return false;
 91         }
 92 
 93         for (int i : arr3)
 94         {
 95             if (i == a)
 96             {
 97                 return true;
 98             }
 99         }
100 
101         return false;
102     }
103     //取两个数组的交集
104     public static int[] intersect(int[] a1, int[] a2)
105     {
106         int count = 0;
107         int[] temp = new int[a1.length<a2.length?a1.length:a2.length];
108         int flag = 0;
109         for (int i = 0; i < a1.length; i++)
110         {
111             for (int j = 0; j < a2.length; j++)
112             {
113                 if (a1[i] == a2[j]&&!cum(temp, a1[i]))
114                 {
115                     temp[count++] = a1[i]==0?flag++:a1[i];
116                     break;
117                 }
118             }
119         }
120         int[] result = new int[count];
121         //int num = 0;
122         for (int i = 0; i < temp.length; i++)
123         {
124             if (temp[i] != 0)
125             {
126                 //result[num++] = temp[i];
127                 result[i] = temp[i];
128             }
129         }
130         if (flag == 1)
131         {
132             result[count-1] = 0;
133         }
134         System.out.println(Arrays.toString(result));
135         return result;
136     }
137     
138     public static int[] differ(int[] a1, int[] a2)
139     {
140         int[] temp = new int[a1.length];
141         int count = 0;
142         for (int i = 0; i < a1.length; i++)
143         {
144             for (int j = 0; j < a2.length; j++)
145             {
146                 if(a1[i]==a2[j])
147                 {
148                     temp[i] = 1;
149                     count++;
150                     break;
151                 }
152             }
153         }
154         
155         
156         int[] result = new int[a1.length-count];
157         int num = 0;
158         for(int i = 0; i < a1.length;i++)
159         {
160             if (temp[i] == 0)
161             {
162                 result[num++] = a1[i]; 
163             }
164         }
165         
166         System.out.println(Arrays.toString(result));
167         return result;
168     }
169     
170     public static int[] differ2(int[] a1, int[] a2)
171     {
172         int[] temp = new int[a1.length];
173         int count = 0;
174         for (int i = 0; i < a1.length; i++)
175         {
176             for (int j = 0; j < a2.length; j++)
177             {
178                 if(a1[i]==a2[j])
179                 {
180                     temp[i] = a1[i];
181                     count++;
182                     break;
183                 }
184             }
185         }
186         
187         int[] result = new int[a1.length-count];
188         int num = 0;
189         for(int i = 0; i < a1.length;i++)
190         {
191             if (temp[i] == 0)
192             {
193                 result[num++] = a1[i]; 
194             }
195         }
196         
197         System.out.println(Arrays.toString(result));
198         return result;
199     }
200 }

 1 package com.wisezone.array;
 2 
 3 public class Test7
 4 {
 5     //定义一个方法，计算字符串的长度（即包含字符的个数）（length()）
 6     public static int length(String str)
 7     {
 8         return str == null?0:str.toCharArray().length;
 9     }
10     //定义一个方法，判断一个字符串是否为空（isEmpty()）
11     public static boolean isEmpty(String a)
12     {
13         return  a == null || a.length() == 0;
14     }
15     //定义一个方法，给定一个索引返回一个字符串中该索引处的字符（charAt()）
16     public static char charAt(String a,int b)
17     {
18         return a == null || !(b >= 0 && b < a.length())?‘ ‘:a.toCharArray()[b];
19     }
20     //定义一个方法，比较两个字符串是否相等（equals()）
21     public static boolean equals(String str,String str2)
22     {
23         if (str == null || str2 == null)
24         {
25             if (str == null && str2 == null)
26             {
27                 return true;
28             }
29             
30             return false;
31         }
32         
33         char[] chars = str.toCharArray();
34         char[] chars2 = str2.toCharArray();
35         if(chars.length != chars2.length)
36         {
37             return false;
38         }
39         for(int i = 0;i < chars.length;i++)
40         {
41             if (chars[i] != chars2[i])
42             {
43                 return false;
44             }
45         }
46         return true;
47     }
48     
49     public static void main(String[] args)
50     {
51         //System.out.println(equals("", null));
52         System.out.println(substring("djaldjfaljdla",50,-1));
53     }
54     //定义一个方法，给定一个起点索引，一个截止索引（不包含在内），截取一个字符串中这两个索引之间的字符并返回一个新的字符串（substring()）
55     public static String substring(String str,int a,int b)
56     {
57         if(str == null)
58         {
59             return null;
60         }
61         
62         if(a < 0)
63         {
64             a = 0;
65         }
66         int len = str.length();
67         if(b < 0 || b >= len)
68         {
69             b = len;
70         }
71         String result = "";
72         for(int i = a;i < b;i++)
73         {
74             result += str.charAt(i);
75         }
76         
77         return result;
78     }
79     //定义一个方法，判断第一个字符串是否以第二个字符串开头（startsWith()）
80 }

 1 package com.wisezone.array;
 2 
 3 import java.util.Arrays;
 4 
 5 public class Test9
 6 {
 7     //任意数字序列“123456”之类，输出它们所有的排列组合
 8     public static void main(String[] args)
 9     {
10         String str = "123456";
11 
12         char[] arr1 = str.toCharArray();
13 
14         char[] arr2 = Arrays.copyOf(arr1, arr1.length);
15 
16         for (int i = 0; i < arr1.length - 1; i++)
17         {
18 
19             for (int j = i + 1; j < arr2.length; j++)
20             {
21 
22                 System.out.println(arr1[i] + "," + arr2[j]);
23             }
24 
25         }
26 
27     }
28 }

 1 package com.wisezone.io;
 2 
 3 import java.io.File;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 /**
 7  * 将东西写入到文件夹中
 8  * @author 王东海
 9  * @date 2016年8月26日
10  * @version v1.0
11  */
12 public class FileDemo
13 {
14     public static void writeTxt(String dir,String fileName,String[] msgs)
15     {
16         File dirFile = new File(dir);
17         dirFile.mkdirs();
18         
19         //FileOutputStream outputStream = null;
20         
21         try(FileOutputStream outputStream = new FileOutputStream(dir + File.separator + fileName);)
22         {
23             //创建一个文件输出流对象
24             
25             for (String text : msgs)
26             {
27                 //把字符串转换成字节数组写入文件
28                 outputStream.write(text.getBytes());
29                 //Windows系统的换行符是\r\n，其他系统是\n
30                 outputStream.write("\n".getBytes());
31                 //强制刷新缓冲通道使数据立即写入到磁盘上
32                 outputStream.flush();
33             }
34         } 
35         catch (IOException e)
36         {
37             e.printStackTrace();
38         }
39         /*finally
40         {
41             try
42             {
43                 //在finally块中关闭文件输出流对象释放资源
44                 outputStream.close();
45             } catch (IOException e)
46             {
47                 e.printStackTrace();
48             }
49         }*/
50     }
51 
52     public static void main(String[] args) throws IOException
53     {
54         File file = new File("E:/21班教学/tt");
55         //创建一个目录
56         //file.mkdir();
57         //创建多个层次目录
58         //file.mkdirs();
59         //创建一个新文件
60         //file.createNewFile();
61         //删除文件
62         //file.delete();
63         
64         //file.renameTo(new File("E:/21班教学/test"));
65         
66         writeTxt("E:/21班教学/aa/bb", "text.txt", new String[]{"hello","world"});
67     }
68 
69 }

  1 package com.wisezone.io;
  2 
  3 import java.io.File;
  4 import java.io.FileFilter;
  5 import java.io.FilenameFilter;
  6 import java.util.Arrays;
  7 
  8 public class IOTest
  9 {
 10     //统计某个目录下文本文件的个数（即后缀名为.txt，.doc，.xml，.docx，.ppt，.xls的文件）
 11     public static int countTxtFiles(String dir)
 12     {
 13         if (dir == null || dir.trim().length() == 0)
 14         {
 15             return 0;
 16         }
 17         
 18         File file = new File(dir);
 19         if (file.isFile())
 20         {
 21             //如果是一个具体的文件则判断该文件是否包含上述后缀，包含则返回1，不包含则返回0
 22             String fileName = file.getName();
 23             if (fileName.endsWith(".txt") || fileName.endsWith(".doc") || fileName.endsWith(".xml")
 24                     || fileName.endsWith(".docx") || fileName.endsWith(".ppt") || fileName.endsWith(".xls"))
 25             {
 26                 return 1;
 27             }
 28             
 29             return 0;
 30         }
 31         
 32         int sum = 0;
 33         
 34         if (file.isDirectory())
 35         {
 36             //如果是有效的目录，则首先获取该目录下的所有文件名
 37             String[] fileNames = file.list();
 38             //如果是一个空目录则直接返回0
 39             if (fileNames == null || fileNames.length == 0)
 40             {
 41                 return 0;
 42             }
 43             //遍历文件名数组，如果文件名包含上述6个后缀名中的一个则计数器加一
 44             for (String fileName : fileNames)
 45             {
 46                 if (fileName.endsWith(".txt") || fileName.endsWith(".doc") || fileName.endsWith(".xml")
 47                         || fileName.endsWith(".docx") || fileName.endsWith(".ppt") || fileName.endsWith(".xls"))
 48                 {
 49                     sum++;
 50                 }
 51             }
 52         }
 53         
 54         return sum;
 55     }
 56     
 57     public static int countTxt(String dir)
 58     {
 59         if (dir == null || dir.trim().length() == 0)
 60         {
 61             return 0;
 62         }
 63         
 64         File file = new File(dir);
 65         //通过传递一个FilenameFilter接口的实现类的对象定义一个文件名判断的规则对文件名进行过滤
 66         return file.list(new FilenameFilter()
 67         {
 68             
 69             @Override
 70             public boolean accept(File dir, String name)
 71             {
 72                 return name.endsWith(".txt") || name.endsWith(".doc") || name.endsWith(".xml")
 73                         || name.endsWith(".docx") || name.endsWith(".ppt") || name.endsWith(".xls");
 74             }
 75         }).length;
 76     }
 77     //找出某个目录下的大文件（即文件大小超过10M的文件），返回文件名数组
 78     public static String[] findBigFiles(String dir)
 79     {
 80         if (dir == null || dir.trim().length() == 0)
 81         {
 82             return null;
 83         }
 84         
 85         File file = new File(dir);
 86         File[] files = file.listFiles(new FileFilter()
 87         {
 88             @Override
 89             public boolean accept(File pathname)
 90             {
 91                 return pathname.length()/1024.0/1024.0 > 10;
 92             }
 93         });
 94         String[] fileNames = new String[files.length];
 95         for (int i = 0; i < files.length; i++)
 96         {
 97             fileNames[i] = files[i].getName();
 98         }
 99         
100         return fileNames;
101     }
102     public static void main(String[] args)
103     {
104         /*System.out.println(countTxtFiles("E:/18班教学/课件补充"));
105         System.out.println(countTxt("E:/18班教学/课件补充"));*/
106         
107         System.out.println(Arrays.toString(findBigFiles("E:/360安全浏览器下载")));
108     }
109 }

 1 package com.wisezone.io02;
 2 
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 /**
 6  * 将想要写的内容写入到文件中
 7  * @author 王东海
 8  * @date 2016年8月29日
 9  * @version v1.0
10  */
11 public class FileUtil
12 {
13     public static void appendData(String filePath,String[] data)
14     {
15         try(FileOutputStream outputStream = new FileOutputStream(filePath, true);)
16         {
17             for (String text : data)
18             {
19                 //ISO-8859-1、GBK、GB2312、UTF-8、UTF-16
20                 //如果Java文件的编码格式是UTF-8，而要输入的文本文件的编码格式不是UTF-8，则需要传入文本文件的编码格式进行转码，否则就会出现乱码
21                 outputStream.write(text.getBytes("GBK"));
22                 outputStream.write("\r\n".getBytes());
23             }
24         } catch (IOException e)
25         {
26             e.printStackTrace();
27         }
28     }
29     
30     public static void main(String[] args)
31     {
32         appendData("E:/21班教学/test/练习.txt", new String[]{"您吃饭了吗？","你好啊！"});
33     }
34 }

以上是关于上机操作编程题的主要内容，如果未能解决你的问题，请参考以下文章

华南农业大学数据结构上机考试

二叉树上机编程大题集合

SQL Server 上机操作题会做的速度进急，，，

华为牛客网机试都是编程么

计算机二级Python最后一题怎么评分啊？

86/88汇编代码的执行调试