collections shuffle看看下面程序，为什么后面那个Collections.binarySearch(l1, "a5"));会输出负数-8呢，前面的都没问题

java怎样用random取随机数

(int)Math.random()*100+1 就能取到1到100间的随机数 你循环20次就好， 但要注意的是如果已经取出的排除掉， 就比如你先得到个20 又得到个20 一定要只先一个， 鉴于这个要求，你可以取出来放到set集合里， 用set的size来判定取到不重复的随机数

JAVA小问题如何获得几个不同的随机数?

你的情况很适合用 List 类，因为可以直接调用 Collections.shuffle 方法进行洗牌、制造随机的效果。 而且 List 的 remove 方法移除元素的同时返回该元素，也就等于（不重复地）发一张牌。 比如： import java.util.*; class C { ????public static void main(String[] args) { ????????// 创建空架（同时覆盖 toString 方法以方便打印） ????????List<String> 牌架 = new ArrayList<String>() { ????????????public String toString() { ????????????????return "牌架里现有 " + size() + " 张牌，如下： " + super.toString() + " "; ????????????} ????????}; ????????// 装牌 ????????for (String 花: "黑桃 红心 梅花 方块".split(" ")) ????????????for (String 值: "A 2 3 4 5 6 7 8 9 10 J Q K".split(" ")) ????????????????牌架.add(花 + 值); ????????System.out.println("《洗牌前》"); ????????System.out.println(牌架); ????????// 洗牌 ????????Collections.shuffle(牌架); ????????System.out.println("《洗牌后》"); ????????System.out.println(牌架); ????????// 从牌架上拿走最后一张 ????????String 最后一张 = 牌架.remove(牌架.size() - 1); ????????System.out.printf("《拿走了最后一张（%s）》%n", 最后一张); ????????System.out.println(牌架); ????????System.out.printf("%n前三张是 %s%n%n", 牌架.subList(0, 3)); ????????// 清除前三张 ????????牌架.subList(0, 3).clear(); ????????System.out.println("《清除前三张后》"); ????????System.out.println(牌架); ????} } =============================================================================== 回答补充： 》我创建了一个数组,里面有52张牌的图片,我现在想连续随机得到N张牌在数组里的下标,请问该怎么写?数组叫ii 如果你不必保持 ii 里图片的次序，把 ii 数组转换成 List 之后，洗牌和派牌等操作就跟上面的程序里示范的一样简单。 代价当然只不过是你必须先学会利用能提供很多便利的 Java 集合类。（反正学会了你以后会受用不尽）。 其实把数组转换成 List 只需要一行代码： ????List<Object> 牌架 = new ArrayList<Object>(Arrays.asList(ii));????// 假设你的图片是 Object 类 但如果情况是你只能通过随机且不重复的下标达到目的，以所有下标作为 List 的元素是一样简单的。比如： import java.util.*; class D { ????public static void main(String[] args) { ????????// 模拟你的 ii 数组 ????????String[] ii = new String[52]; ????????int index = 0; ????????for (String 花: "黑桃 红心 梅花 方块".split(" ")) ????????????for (String 值: "A 2 3 4 5 6 7 8 9 10 J Q K".split(" ")) ????????????????ii[index++] = 花 + 值; ????????// 创建所有下标，然后打乱全部 ????????List<Integer> indexes = new ArrayList<Integer>(); ????????for (int i = 0; i < 52; i++) ????????????indexes.add(i); ????????Collections.shuffle(indexes); ????????// 用前三个下标打印随机三张牌，然后把它们从 indexes 中删去以避免重复 ????????List<Integer> someIdx = indexes.subList(0, 3); ????????for (int idx: someIdx) ????????????System.out.println(ii[idx]); ????????someIdx.clear(); ????} }

演示一副牌中所有的牌java编程题目

/** * 扑克牌游戏： * 使用集合类来模拟实现洗牌和发牌工作。 * * 解析：1、首先设定玩牌的人数，如4人； 2、设定每人拿牌的数量； * 3、创建52张牌的数组； 4、创建洗牌的方法"card()" ； * 5、在方法中创建ArrayList对象； 6、循环把52张牌加入到集合对象中； * 7、调用算法类“Collection”中的方法“shuffle”完成洗牌功能； 8、首先取得牌的总张数； * 9、使用方法subList从list的后面发出13张牌； 10、将发出的牌从list中删除； * 11、返回每个人的13张牌。 */ package poker; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Card { private int adultNumber = 4; // 定义adultNumber属性，用于设定牌鬼数量。 /** * 无参构造方法 */ public Card() { } /** * 定义run()方法，用于统筹全局。 */ public void run() { System.out.println("有" + adultNumber + "个牌鬼打牌。"); // 看每个人均分能够得到多少张牌。 int cardNumberAverage = 54 / adultNumber; // 把一副牌给每个人均分后剩余多少张牌。 int cardNumberSurplus = 54 % adultNumber; if (cardNumberSurplus == 0) { System.out.println("各拿" + cardNumberAverage + "张牌，" + "无剩余牌数。"); } else if (cardNumberSurplus > 0) { System.out.println("各拿" + cardNumberAverage + "张牌，" + "特殊牌数：" + cardNumberSurplus); } ArrayList<String> arrayList = this.cardNumberArray(); this.perHand(arrayList, cardNumberAverage); } /** * 定义cardNumberArray()方法，用于设定扑克牌数组。 */ private ArrayList<String> cardNumberArray() { ArrayList<String> arrayList = new ArrayList<String>(); String[] arrayStyle = new String[]{ "黑桃", "梅花", "红桃", "方块" }; String[] arraySeries = new String[]{ "Ace", "2", "3", "4", "5","6", "7", "8", "9", "10", "Jack", "Queen", "King"}; for (int i = 0; i < arrayStyle.length; i++) { for (int j = 0; j < arraySeries.length; j++) { arrayList.add(arrayStyle[i] + arraySeries[j]); } } this.card(arrayList); // 调用洗牌方法card()。 return arrayList; } /** * 定义card()方法，用于扑克游戏中的洗牌。 */ private void card(ArrayList<String> arrayList) { // 调用算法类“Collection”中的方法“shuffle”完成洗牌功能. Collections.shuffle(arrayList); } /** * 定义perHand()方法，用于扑克游戏中的发牌。 */ private void perHand(ArrayList<String> arrayList, int cardNumberAverage) { for (int i = 0; i < adultNumber; i++) { // 取得洗牌后的总牌数. int arrayListNewNumber = arrayList.size(); // System.out.println(arrayListNewNumber); // 使用方法subList从list的后面发出13张牌. List presentCardNumber = arrayList.subList(arrayListNewNumber - cardNumberAverage, arrayListNewNumber); System.out.println("第"+(i+1)+"个人的牌是："+presentCardNumber); //显示剩余牌数。 // System.out.println(arrayListNewNumber - cardNumberAverage); List tempCardNumber = new ArrayList(presentCardNumber); // 将发出的牌从list中删除 arrayList.removeAll(tempCardNumber); } } /** * 扑克牌游戏： * 使用集合类来模拟实现洗牌和发牌工作。 */ public static void main(String[] args) { Card card = new Card(); card.run(); } }

Java代码实现抽奖:从班级的学号中抽出一个一等奖,两个二等奖,三个三等奖

抽取问题, 重点是 同一个学号不能重复被抽取. 解决办法很多, 1. 比如数组可以使用下标来标记,号码是否被使用,使用了就继续下一次抽取 2. 也可以使用集合来抽取,把集合顺序打乱,然后随便抽几个就可以了 参考代码:数组法 import?java.util.Random; public?class?Test?{ public?static?void?main(String[]?args)?{ int?stuNums=30; int[]?nums=new?int[stuNums];//存储学号的数组 boolean[]?flags=new?boolean[stuNums];//标记,用于标记对应下标的学号是否已经被抽取过了 for?(int?i?=?0;?i?<?stuNums;?i++)?{ nums[i]=i+1;//给学号赋值 } Random?r=new?Random(); while(true){ int?index?=?r.nextInt(stuNums); if(!flags[index]){ System.out.println("A等:"+nums[index]); flags[index]=true;?//标记已经被使用过了 break; } } for?(int?i?=?0;?i?<?2;?i++)?{ int?index?=?r.nextInt(stuNums); if(!flags[index]){ System.out.println("B等:"+nums[index]); flags[index]=true; }else{ i--;//如果已经被抽取过了?,那么i建议,再次循环 } } for?(int?i?=?0;?i?<?3;?i++)?{ int?index?=?r.nextInt(stuNums); if(!flags[index]){ System.out.println("c等:"+nums[index]); flags[index]=true; }else{ i--; } } } }集合法 import?java.util.ArrayList; import?java.util.Collections; public?class?Test2?{ public?static?void?main(String[]?args)?{ int?stuNums=20; ArrayList<Integer>?list=new?ArrayList<Integer>(); for?(int?i?=?0;?i?<?stuNums;?i++)?{ list.add(i+1); } System.out.println("有序"+list); Collections.shuffle(list);//打乱顺序 System.out.println("乱序"+list); System.out.println("A等"+list.get(0)); System.out.println("B等"+list.get(1)); System.out.println("B等"+list.get(2)); System.out.println("C等"+list.get(3)); System.out.println("C等"+list.get(4)); System.out.println("C等"+list.get(5)); } }

这个程序是不是 还要导入一个包 List 的用法

接口List与类Collections都是在java.util包中，所以应该在代码最开始写上import java.util.List; import java.util.Collections; 或者直接import java.util.*;

Collections.shuffle中以毫秒为随机种子,应该怎么写?

shuffle只接收一个Random对象为随机生成提供支持,你可以使用当前毫秒数构造一个Random对象 Random r = new Random(System.currentTimeMillis());

123456789分别填在[ ] [ ] [ ] [ ] ×[ ]=[ ] [ ] [ ] [ ]

1738 x 4 = 6952 1963 x 4 = 7852

不知道还有没有其他答案，我就找出来2个，是用程序算出来的：

JAVA源代码如下：

import java.util.ArrayList; import java.util.Collections;

public class Test {

 public static void main(String[] args) {   ArrayList<Integer> arrayList = new ArrayList<Integer>();   for (int i = 1; i <= 9; i++) {    arrayList.add(i);   }   while (true) {    Collections.shuffle(arrayList);    if (arrayList.get(4) == 1 || arrayList.get(4) == 9      || arrayList.get(3) == 1 || arrayList.get(8) == 1) {     continue;    }    int a = arrayList.get(0) * 1000 + arrayList.get(1) * 100      + arrayList.get(2) * 10 + arrayList.get(3);    int b = arrayList.get(4);    int c = arrayList.get(5) * 1000 + arrayList.get(6) * 100      + arrayList.get(7) * 10 + arrayList.get(8);    if (a * b == c)     System.out.println(a + " x " + b + " = " + c);   }  } }

 

面这行代码中的“？”以及shuffle 都是什么意思

Shuffle过程是MapReduce的核心，也被称为奇迹发生的地方。要想理解MapReduce， Shuffle是必须要了解的。我看过很多相关的资料，但每次看完都云里雾里的绕着，很难理清大致的逻辑，反而越搅越混。前段时间在做MapReduce job 性能调优的工作，需要深入代码研究MapReduce的运行机制，这才对Shuffle探了个究竟。考虑到之前我在看相关资料而看不懂时很恼火，所以在这里我尽最大的可能试着把Shuffle说清楚，让每一位想了解它原理的朋友都能有所收获。 Shuffle的正常意思是洗牌或弄乱，可能大家更熟悉的是Java API里的Collections.shuffle(List)方法，它会随机地打乱参数list里的元素顺序。

raptor中怎样设置循环数组

Button b1, b2, b3, b4, b5; Button[] buttons = { b1, b2, b3, b4, b5 }; public void shuffleButtons() { Integer[] Id = { R.id.bChoice1, R.id.bChoice2, R.id.bChoice3, R.id.bChoice4, R.id.bChoice5 }; ArrayList<Integer> buttonId = new ArrayList<Integer>(Arrays.asList(Id)); Collections.shuffle(buttonId); for (int x = 0; x < 5; x++) { for (Button b : buttons) { b = (Button) findViewById(buttonId.get(x)); } } }

java中Math.random();算法

import java.util.ArrayList; import java.util.List; import java.util.Random; public class Card { public static void main(String[] args) { List<String> list=new ArrayList<String>(); //初始化 for(int i=0;i<4;i++){ for(int j=0;j<13;j++){ list.add("花色："+(i+1)+"大小："+(j+1)); } } //洗牌.都是随即分配洗不洗e799bee5baa6e59b9ee7ad9431333238646365无所谓 // Collections.shuffle(list); // for(String s:list){ // System.out.println(s); // } //分牌 Random random=new Random(); for(int j=0;j<4;j++){ System.out.println("发给第"+(j+1)+"个人的牌："); for(int i=0;i<13;i++){ System.out.println(list.get(random.nextInt(list.size()-1))); } } } }

Java中Collection和Collections的区别

1. Collection是集合类的一个顶级接口，其直接继承接口有List与Set 　　而Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。 　　1) 排序(Sort) 　　使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的 double array[] = {112, 111, 23, 456, 231 }; for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } Collections.sort(list); for (int i = 0; i < array.length; i++) { System.out.println(li.get(i)); } //结果：112,111,23,456,231 　　2) 混排（Shuffling） 　　混排算法所做的正好与 sort 相反: 打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List, 这样的排列具有相同的可能性。这个算法在实现一个碰运气的游戏中是非常有用的。例如，可用来混排代表一副牌的 Card 对象的一个 List 。另外，在生成测试案例时，也是十分有用的。 Collections.Shuffling(list) double array[] = {112, 111, 23, 456, 231 }; for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } Collections.shuffle(list); for (int i = 0; i < array.length; i++) { System.out.println(li.get(i)); } //结果：112,111,23,456,231 　　3) 反转(Reverse) 使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。 Collections.reverse(list) double array[] = {112, 111, 23, 456, 231 }; for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } Collections. reverse (list); for (int i = 0; i < array.length; i++) { System.out.println(li.get(i)); } //结果：231,456,23,111,112 　　4) 替换所以的元素(Fill) 　　使用指定元素替换指定列表中的所有元素。 String str[] = {"dd","aa","bb",&","ee"}; for(int j=0;j<str.length;j++){ li.add(new String(str[j])); } Collections.fill(li,"aaa"); for (int i = 0; i < li.size(); i++) { System.out.println("list[" + i + "]=" + li.get(i)); } //结果：aaa,aaa,aaa,aaa,aaa 　　5) 拷贝(Copy) 　　用两个参数，一个目标 List 和一个源 List, 将源的元素拷贝到目标，并覆盖内容。目标 List 至少与源一样长。如果更长，则在目标 List 中的剩余元素不受影响。 Collections.copy(list,li): 后面一个参数是目标列表 ,前一个是源列表 double array[] = {112, 111, 23, 456, 231 }; List list = new ArrayList(); List li = new ArrayList(); for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } double arr[] = {1131,333}; String str[] = {"dd","aa","bb",&","ee"}; for(int j=0;j<arr.length;j++){ li.add(new Double(arr[j])); } Collections.copy(list,li); for (int i = 0; i <list.size(); i++) { System.out.println("list[" + i + "]=" + list.get(i)); } //结果：1131,333,23,456,231 　　6) 返回Collections中最小元素(min) 　　根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的 Collections.min(list) double array[] = {112, 111, 23, 456, 231 }; List list = new ArrayList(); for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } Collections.min(list); for (int i = 0; i <list.size(); i++) { System.out.println("list[" + i + "]=" + list.get(i)); } //结果：23 　　7) 返回Collections中最小元素(max) 　　根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的 Collections.max(list) double array[] = {112, 111, 23, 456, 231 }; List list = new ArrayList(); for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } Collections.max(list); for (int i = 0; i <list.size(); i++) { System.out.println("list[" + i + "]=" + list.get(i)); } //结果：456 　　8) lastIndexOfSubList 　　返回指定源列表中最后一次出现指定目标列表的起始位置 int count = Collections.lastIndexOfSubList(list,li); double array[] = {112, 111, 23, 456, 231 }; List list = new ArrayList(); List li = new ArrayList(); for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } double arr[] = {111}; String str[] = {"dd","aa","bb",&","ee"}; for(int j=0;j<arr.length;j++){ li.add(new Double(arr[j])); } Int locations = Collections. lastIndexOfSubList (list,li); System.out.println(“===”+ locations); //结果 3 　　9) IndexOfSubList 　　返回指定源列表中第一次出现指定目标列表的起始位置 int count = Collections.indexOfSubList(list,li); double array[] = {112, 111, 23, 456, 231 }; List list = new ArrayList(); List li = new ArrayList(); for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } double arr[] = {111}; String str[] = {"dd","aa","bb",&","ee"}; for(int j=0;j<arr.length;j++){ li.add(new Double(arr[j])); } Int locations = Collections.indexOfSubList(list,li); System.out.println(“===”+ locations); //结果 1 　　10) Rotate 　　根据指定的距离循环移动指定列表中的元素 Collections.rotate(list,-1); 如果是负数，则正向移动，正数则方向移动 double array[] = {112, 111, 23, 456, 231 }; List list = new ArrayList(); for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } Collections.rotate(list,-1); for (int i = 0; i <list.size(); i++) { System.out.println("list[" + i + "]=" + list.get(i)); } //结果：111,23,456,231,112

Java问题shuffleArray

举个例子吧 a[6] 下标分别是 0 1 2 3 4 5 然后用romdom取出0~5中随机一个整数 比如是2 那就让a[0] 和 a[2] 调换数据。 第二次取1~5 比如是2 此时就让新的下标的a[1] 和 a[2] 调换 如此循环6-1次 就得到打乱的数组了 list的话也是同样一个道理

java中collections类的shuffle方法是怎么实现的

// ShuffleTest.java import java.util.*; public class ShuffleTest { public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); for (int i = 0; i < 10; i++) list.add(new Integer(i)); System.out.println("打乱前:"); System.out.println(list); for (int i = 0; i < 5; i++) { System.out.println("第" + i + "次打乱："); Collections.shuffle(list); System.out.println(list); } } }

实现一个生成10个随机整数(范围: 50-100)， 分别显示无序原始数据，以及按递减排列的数据。

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApp2 { class Program { static void Main(string[] args) { byte[] buffer = Guid.NewGuid().ToByteArray();//生成字节数组 int iRoot = BitConverter.ToInt32(buffer, 0);//利用BitConvert方法把字节数组转换为整数 Random rdmNum = new Random(iRoot);//以这个生成的整数为种子 int[] nums = new int[10]; for (int i = 0; i < 10; i++) { nums[i] = rdmNum.Next(50, 100); } Console.WriteLine("打印数组"); printNums(nums); Array.Sort(nums);//排序 nums.Reverse();//降序 Console.WriteLine("打印降序数组"); printNums(nums); } static void printNums(int[] nums) { foreach(var n in nums) { Console.WriteLine(n); } } } }

SHUFFLE最后的结局是什么？

[动画]shuffle 剧情简介： 故事发生在一所名为国立巴贝那学园的高校，普通高中生土见禀与自幼青梅竹马的女孩枫一起过着快乐安详的生活。因为10年前的一场巨变，神·人·魔三界的通道被打开，神界和魔界的居民开始在人界自由同行，三界的种族开始共同生活在一个社会里，随着时间的推移，人们也慢慢习以为常了。 某日，来自神界和魔界的两位美少女转校到巴贝那学园，她们为了寻找儿时的邂逅决定留在人界。从此禀的生活开始发生某种仿佛注定了的变化…… 关于原作： [Shuffle!!]原作是连载于角川书店《月刊コンプティーク》的人气恋爱喜剧，曾经创造了单行本销售10万册，角色小说2万册的佳绩。著名恋爱游戏厂牌Navel以SHUFFLE为主题的几款游戏也极具人气。漫画游戏动画均由著名原画家西又葵、铃平ひろ担任人物原型设计，西又葵有其人见人爱的“栗子脸电眼美女”，铃平ひろ则继续Soul Link中的瓜子脸尖下巴美女造型设定，两者相互辉映，相得益彰。 出于Love Comedy（爱情喜剧）的基调，剧中众多美少女或活泼可爱，擅长运动；或成熟稳重，料理家务；又或学习出众，人气爆棚，围绕着男主角展开清新、温存，又带一点笑料的校园剧。 西又葵，前排左一。**游戏界以及ACG界著名原画师，作品多不胜数，近期比较受关注的有不久前的美少女动画《爱情泡泡糖》，其中西又葵担任了人设和原画。 铃平ひろ，前排左三。同为著名原画师，作品多为游戏。曾与多位原画师一同参与游戏《Soul Link》的人设和原画。最具人气的作品是游戏《Monochrome》，是Navel的金牌画师。 当然，两位大叔都与HGAME脱不了干系，带领众多I—I的fans们一起“堕落”…… STAFF & CAST： STAFF： 原作：Navel 原案イラスト：西又葵??铃平ひろ 连载：月刊「コンプティーク」??角川コミックス??エース刊 シリーズ构成：铃木雅词 キャラクターデザイン??総作画监督：平山英嗣 音楽：アッチョリケ（Navel） 音楽プロデューサー：虻川治（ランティス） 音楽制作：ランティス 音响监督：鹤冈阳太 编集：伊藤润一（ジェイフィルム） 美术监督：高山八大（プロダクションアイ） 撮影监督：森下成一（スタジオトウィンクル） 色彩设定：福谷直树（スタジオロン） アニメーションプロデューサー：平松巨规 音响スタジオ：スタジオごんぐ 音响制作：楽音舎 アニメーション制作：アスリード 监督：细田直人 制作：SHUFFLE! Media Partners CAST： 土见禀：杉田智和 リシアンサス：あおきさやか ネリネ：永见はるか 芙蓉枫：后藤邑子 时雨亜沙：伊藤美纪 プリムラ：ひと美 麻弓＝タイム：井上美纪 绿叶树：荻原秀树 カレハ：日向裕罗 时雨亜麻：YURIA 红蔷薇抚子：竹间千ノ美 神王：小杉十郎太 魔王：森川智之

用JAVA写个代码，实现52张牌随机分给四个人

//参考了楼上的建议，调试成功…… 我也是第一次用这个洗牌方法，还不错…… 里面写了个方法，只要是生成扑克牌的list，排的花色我随便用的字母表示的，自己看吧，记得追加点分 import java.util.ArrayList; import java.util.List; import java.util.Collections; public class XiPai { private String Rt="rt"; //red private String Bt="Bt"; //black private String Fp="FP"; private String Mh="MH"; public List getPKList(){ String pkColor = ""; String pkNum; List pkList = new ArrayList(); for(int i=1;i<=4;i++){ if(i==1){ pkColor=Rt; }else if(i==2){ pkColor=Bt; }else if(i==3){ pkColor=Fp; }else{ pkColor=Mh; } for(int j=1;j<=13;j++){ pkNum=j+pkColor; pkList.add(pkNum); } } Collections.shuffle(pkList); System.out.println(pkList.size()); for(int k=0;kJAVA中Math.random();public class A { public String[][] createArr() { String[][] strArr = new String[10][10]; int radnum; for(int i=0;i<10;i++) { for(int j=0;j<10;j++) { radnum = (int)(Math.random()*10); strArr[i][j] = radnum + ".jpg"; } } return strArr; } }

Java编写52张牌四人十三张随机发牌

import java.util.ArrayList; import java.util.List; import java.util.Collections; public class XiPai { private String Rt="rt"; //red private String Bt="Bt"; //black private String Fp="FP"; private String Mh="MH"; public List getPKList(){ String pkColor = ""; String pkNum; List pkList = new ArrayList(); for(int i=1;i if(i==1){ pkColor=Rt; }else if(i==2){ pkColor=Bt; }else if(i==3){ pkColor=Fp; }else{ pkColor=Mh; } for(int j=1;j pkNum=j+pkColor; pkList.add(pkNum); } } Collections.shuffle(pkList); System.out.println(pkList.size()); for(int k=0;k System.out.print(" "+pkList.get(k).toString()); } return pkList; } public static void main(String[] args) { // TODO Auto-generated method stub XiPai x = new XiPai(); x.getPKList(); } }

java:用while循环,输入a=1,2,3,4,5,6,输出a=6,,5,4,3,2,1,

是不是：把你输入的数字按从大到小排序？ public static void main(String[] args) { int count=0; List<Integer> arr=new ArrayList<Integer>(); while(count<6){ Scanner input=new Scanner(System.in); int num=input.nextInt(); count++; arr.add(num); } int position=0; for(int i=0;i<arr.size();i++){ int j=i+1; position=i; int temp=arr.get(i); for(;j<arr.size();j++){ if(arr.get(j)>temp){ temp=arr.get(j); position=j; } } arr.set(position, arr.get(i)); arr.set(i, temp); } for(int i=0;i<arr.size();i++){ System.out.println(arr.get(i)); } }

关于java输出一组无序整数

Collections.shuffle(list); 进行乱序之后还是会有重复的数的 list可以重复 不能重复用set public class Summation { public static void main(String aa[]) { ArrayList<Integer> list=new ArrayList<Integer>(); list.add(10); list.add(30); list.add(20); list.add(50); list.add(30); Collections.shuffle(list); int[] array=new int[list.size()]; for(int i=0;i<list.size();i++){ array[i]=list.get(i); } System.out.println("array"+Arrays.toString(array)); System.out.println("list"+list); }} 这是我写的代码 你可以参考一下 看你是否是这个需求。

java容器 list 容器随机遍历

List?strs?=?new?ArrayList<>(); strs.add("1"); strs.add("2"); strs.add("3"); if(strs.size()?>?0){ //列表不为空才做操作 Collections.shuffle(strs);//随机打乱列表顺序 Random?r?=?new?Random(1000);//随机数获取类 int?index?=?r.nextInt(strs.size());//获取一个整数，范围在0到strs.size()-1之间 System.out.println("随机访问："+strs.get(index)); }

JAVA编程创建一个List集合cards,再54张扑克牌存放到其中，请按下列要求编写程序：

public class PlayCard { private List list; /** * JAVA编程创建一个List集合cards,再54张扑克牌存放到其中 * (1)用3种不同方法输出54张牌； * (2)调用Collections方法随机分派54张牌 */ public PlayCard() { list = new ArrayList(); for(int i=1;i<55;i++){ list.add(i); } } public void showPlayCard(){ System.out.println("方式一"); for(Integer i : list){ System.out.print(i+" "); } System.out.println("方式二"); for(int i=0;i System.out.print(list.get(i)+" "); } System.out.println("方式三"); Iterator< Integer> it = list.iterator(); while(it.hasNext()){ System.out.print(it.next()+" "); } } // TODO调用Collections方法随机分派54张牌 public void randomPlayCards(){ // 把牌打乱 Collections.shuffle(list); } public static void main(String[] args) { PlayCard p = new PlayCard(); p.randomPlayCards(); p.showPlayCard(); } }

collections类中哪个方法向列表中填充元素 copy fill sort shuffle

[java] view plain copy package ocm.axb.cheney.collection; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class CollectionSort { public CollectionSort() { } @SuppressWarnings("unchecked") public static void main(String args[]) { double array[] = { 111, 22, 333, 40, 10, 411 }; double targetArray[] = { 1, 2, 10, 4, 7, 6 }; List list1 = new ArrayList(); List list2 = new ArrayList(); returnList(list1, array); returnList(list2, targetArray); // 使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 // Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的 //Collections.sort(list1); /* 混排（Shuffling） 混排算法所做的正好与 sort 相反: 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List, 这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card 对象的一个 List 。另外，在生成 测试案例时，它也是十分有用的*/ //Collections.shuffle(list1); //反转(Reverse) 使用Reverse方法可以先根据元素的自然顺序(Collections.sort(list1);)再对指定列表按降序进行排序 //Collections.reverse(list1); //替换所以的元素(Fill)使用指定元素替换指定列表中的所有元素。 //Collections.fill(list1, "aaa"); //拷贝(Copy) 用两个参数，一个目标 List 和一个源 List, 将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与 //源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。 Collections.copy(list,li): 后面一个参数是目标列表 ,前一个是源列表 //Collections.copy(list1,list2); //返回Collections中最小元素(min)或者最大元素（max） //根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指 //定比较器可相互比较的 //System.out.println(Collections.min(list1)); //System.out.println(Collections.max(list1)); //交换一个线性表中两个元素的位置。 Collections.swap(list1, 0, 1); for (int i = 0; i < array.length; i++) { System.out.println(list1.get(i)); } } @SuppressWarnings("unchecked") public static List returnList(List list, double array[]) { for (int i = 0; i < array.length; i++) { list.add(new Double(array[i])); } return list; } }

题目：编写程序,模拟扑克游戏中的洗牌过程.(只选红桃模拟)。用java怎么弄？

洗牌过程？一句话就完成洗牌过程了！！ 代码如下： import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class CardGame { public static void main(String[] args) throws IOException { String[] types={"黑桃","草花","红心","方块"}; String[] value={"2","3","4","5","6","7","8","9","10","J","Q","K","A"}; String[] king={"JOKER","joker"}; List<String> cards=new ArrayList<String>();//将一副牌54张放入待洗牌的集合中 for(int i=0;i<types.length;i++){ for(int j=0;j<value.length;j++){ cards.add(types[i]+value[j]);//每个花色的2-A } } cards.add(king[0]);//大鬼 cards.add(king[1]);//小鬼 int m=0; System.out.println("洗牌之前---------------------------------------------------- "); for(String str:cards) { System.out.print(str+" "); m++; if(m%13==0) System.out.println(); } Collections.shuffle(cards);//洗牌动作 m=0; System.out.println(" 洗牌之后----------------------------------------------------- "); for(String str:cards)//输出洗牌后的结果 { System.out.print(str+" "); m++; if(m%13==0) System.out.println(); } } } 我在这里把所有的花色都加入一起洗牌了，楼主可根据需要进行特殊花色的洗牌！！你多执行几次就会发现每次洗牌后的牌的位置都不是一样的！！关键在一个洗牌动作的方法！！

看看下面程序，为什么后面那个Collections.binarySearch(l1, "a5"));会输出负数-8呢，前面的都没问题

binarySearch 使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过 sort(List) 方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。 如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。