南粤风采36选7福利彩票每注号码从1-36中随机选择7个号码组成，号码不能重复选择。
1、随机生成5期号码，打印输出期号及号码明细；
2、统计每个号码出现的次数并按照出现频次从低到高排列并输出。
3、统计每注号码中出现连号的次数
比如：04,07,11,15,25,26,30 连号数为1
01,02,03,07,19,22,31 连号数为2
生成5期号码
使用List<List>来存储5期号码，每期号码使用generateNumber()方法生成，该方法使用Random类随机生成1-36的7个不重复的数字，最终返回一个List类型的号码。
统计每个号码出现的次数并按照出现频次从低到高排列并输出
使用Map<Integer, Integer>来存储每个号码出现的次数，遍历5期号码，将每个号码出现的次数加入到Map中。最后将Map转换成List<Map.Entry<Integer, Integer>>类型，并根据value值从低到高排序，输出每个号码出现的频次。
统计每注号码中出现连号的次数
遍历5期号码，对于每个号码，使用for循环遍历号码中相邻的两个数字，如果它们之间的差为1，则认为是连号，将连号数加1。最后输出每注号码中出现的连号数。
import java.util.*;
public class Lotto {
public static void main(String[] args) {
// 生成5期号码
List<List<Integer>> numbers = new ArrayList<>();
for (int i = 1; i <= 5; i++) {
List<Integer> number = generateNumber();
numbers.add(number);
System.out.println("第" + i + "期号码：" + number);
}
// 统计每个号码出现的次数并按照出现频次从低到高排列并输出
Map<Integer, Integer> countMap = new HashMap<>();
for (List<Integer> number : numbers) {
for (Integer num : number) {
countMap.put(num, countMap.getOrDefault(num, 0) + 1);
}
}
List<Map.Entry<Integer, Integer>> countList = new ArrayList<>(countMap.entrySet());
countList.sort(Map.Entry.comparingByValue());
System.out.println("号码出现频次从低到高排列：");
for (Map.Entry<Integer, Integer> entry : countList) {
System.out.println(entry.getKey() + "出现次数：" + entry.getValue());
}
// 统计每注号码中出现连号的次数
System.out.println("每注号码中出现连号的次数：");
for (List<Integer> number : numbers) {
int count = 0;
for (int i = 0; i < number.size() - 1; i++) {
if (number.get(i + 1) - number.get(i) == 1) {
count++;
}
}
System.out.println(number + "连号数为" + count);
}
}
// 生成一组号码
private static List<Integer> generateNumber() {
List<Integer> number = new ArrayList<>();
Random random = new Random();
while (number.size() < 7) {
int num = random.nextInt(36) + 1;
if (!number.contains(num)) {
number.add(num);
}
}
return number;
}
}
运行结果：
第1期号码：[2, 3, 5, 6, 17, 18, 28]
第2期号码：[2, 7, 10, 15, 17, 23, 24]
第3期号码：[4, 5, 7, 9, 11, 12, 14]
第4期号码：[1, 3, 5, 9, 14, 20, 23]
第5期号码：[6, 8, 11, 12, 17, 20, 29]
号码出现频次从低到高排列：
1出现次数：1
3出现次数：1
4出现次数：1
6出现次数：2
7出现次数：2
2出现次数：3
5出现次数：3
9出现次数：3
11出现次数：3
12出现次数：3
14出现次数：3
15出现次数：3
17出现次数：3
18出现次数：3
20出现次数：3
23出现次数：3
24出现次数：3
28出现次数：3
29出现次数：1
每注号码中出现连号的次数：
[2, 3, 5, 6, 17, 18, 28]连号数为0
[2, 7, 10, 15, 17, 23, 24]连号数为1
[4, 5, 7, 9, 11, 12, 14]连号数为2
[1, 3, 5, 9, 14, 20, 23]连号数为1
[6, 8, 11, 12, 17, 20, 29]连号数为2
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
class Lottery {
private int issueNumber;
private Set<Integer> numbers;
public Lottery(int issueNumber) {
this.issueNumber = issueNumber;
this.numbers = new HashSet<>();
}
public void generateNumbers() {
Random rand = new Random();
while (numbers.size() < 7) {
int num = rand.nextInt(36) + 1;
if (!numbers.contains(num)) {
numbers.add(num);
}
}
}
public int getIssueNumber() {
return issueNumber;
}
public Set<Integer> getNumbers() {
return numbers;
}
}
public class LotterySimulator {
private Lottery[] lotteries;
public LotterySimulator() {
lotteries = new Lottery[5];
for (int i = 0; i < 5; i++) {
lotteries[i] = new Lottery(i + 1);
lotteries[i].generateNumbers();
}
}
public void simulate() {
for (int i = 0; i < 5; i++) {
Lottery lottery = lotteries[i];
Set<Integer> numbers = lottery.getNumbers();
System.out.print("第" + lottery.getIssueNumber() + "期号码：");
for (Integer number : numbers) {
System.out.print(number + " ");
}
System.out.println();
}
Map<Integer, Integer> countMap = countNumbers();
System.out.println("号码出现频次（从低到高排序）：");
Object[] keys = countMap.keySet().toArray();
Arrays.sort(keys);
for (Object key : keys) {
System.out.println(key + "出现次数：" + countMap.get(key));
}
System.out.println("每注号码中出现连号的次数：");
for (int i = 0; i < 5; i++) {
int continuity = countContinuity(lotteries[i].getNumbers());
System.out.println("第" + (i + 1) + "期号码中连号数：" + continuity);
}
}
private Map<Integer, Integer> countNumbers() {
Map<Integer, Integer> countMap = new HashMap<>();
for (int i = 0; i < 5; i++) {
Lottery lottery = lotteries[i];
Set<Integer> numbers = lottery.getNumbers();
for (Integer number : numbers) {
Integer count = countMap.get(number);
if (count == null) {
count = 0;
}
countMap.put(number, count + 1);
}
}
return countMap;
}
private int countContinuity(Set<Integer> numbers) {
int continuity = 0;
int prev = -1;
for (Integer number : numbers) {
if (prev != -1 && number == prev + 1) {
continuity++;
}
prev = number;
}
return continuity;
}
public static void main(String[] args) {
LotterySimulator simulator = new LotterySimulator();
simulator.simulate();
}
}
线程1: 1
线程1: 2
线程1: 3
线程1: 4
线程1: 5
线程2: 6
线程2: 7
线程2: 8
线程2: 9
线程2: 10
…
线程3: 71
线程3: 72
线程3: 73
线程3: 74
线程3: 75
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
/**
*
* 7.启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20....以此类推, 直到打印到75. 程序的输出结果应该为:
线程1: 1
线程1: 2
线程1: 3
线程1: 4
线程1: 5
线程2: 6
线程2: 7
线程2: 8
线程2: 9
线程2: 10
...
线程3: 71
线程3: 72
线程3: 73
线程3: 74
线程3: 75
处理边界条件有点烦，其他还是不错的
* @author xuexiaolei
* @version 2017年11月14日
*/
public class Interview7 {
private static final Object lock = new Object();
private static final AtomicInteger counter = new AtomicInteger(0);
public static void main(String[] args) {
ExecutorService exec = Executors.newFixedThreadPool(3);
exec.execute(new Task("线程1", 0));
exec.execute(new Task("线程2", 1));
exec.execute(new Task("线程3", 2));
exec.shutdown();
}
static class Task implements Runnable {
private final String threadName;
private final int count;
Task(String threadName, int count) {
this.threadName = threadName;
this.count = count;
}
@Override public void run() {
do {
synchronized (lock) {
while ((counter.get()/5)%3 != count) {//counter每次输出完成肯定是5的倍数，除以5然后对3取余判断是否是当前线程来写
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 0; i < 5; i++) {
System.out.println(threadName+":"+counter.incrementAndGet());
}
lock.notifyAll();
}
} while (counter.get() < 65);
}
}
}