189 8069 5689
这个是java中的不定长参数(Variable-length Argument),下面详细说明一下：
10年积累的网站设计制作、做网站经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先做网站后付款的网站建设流程，更有乐业免费网站建设让你可以放心的选择与我们合作。
不定长参数的由来：
我们在调用某个方法的时候，如果事先无法决定参数的个数，例如最简单的输出语句：System.out.println()；这里面是无法事先决定要给的参数的个数的，比如输出一个a1，就要写System.out.println(a1)；如果输出两个，就要改为System.out.println(a1，a2)；怎么解决这个问题呢？
自J2se5.0之后开始支持不定长参数(Variable-length Argument),这样就可以直接解决上述问题，来看一个范例：
public class Variable{
public static int sum(int... nums){ //使用...声明参数
int sum = 0;
for(int num : nums){
sum+=num;
}
return sum;
}
这个范例就介绍了不定长参数的用法，其中...就是它的标志，要加在类型关键词后面。其实仔细分析一下可知，nums就是一个数组，编译器会将参数行的(int... nums)解释为（int[] nums）。下面我们就来使用一下上面的这个使用了不定长参数的方法，代码如下：
public class TestVariable{
public static void main(String[] args){
int sum = 0;
sum = Variable.sum(1,2);
System.out.println("1+2="+sum);
sum = Variable.sum(1,2,3);
System.out.println("1+2+3="+sum);
sum = Variable.sum(1,2,3,4,5);
System.out.println("1+2="+sum);
}
}
}
分析可知，编译器会将传递给方法的参数解释为int数组传入至sum()中，所以实际上不定长参数的功能也是自J2se5.0之后所提供的编译蜜糖(Compiler Sugar).
现在来说一下你说的情况，你说的public void method(Class... aaa){} ，这个是使用对象的不定长参数，这个Class当然可以换成其他的东西了，可以换成任何能够作为参数来传递的东西，相信看了上面的话，你也早就明白了，呵呵……
最后我还要说明一下不定长参数使用时候的注意事项：
1：在使用不定长参数时，记得必须声明的参数必须设置在参数行的最后一个，来具体看几个例子：
public void someMethod(int arg1,int arg2,int... varargs){} (正确的)
public void someMethod(int... varargs,int arg1,int arg2){} (错误的)
2：不能使用两个以上的不定长参数，例如下面的方式是不合法的
public void someMethod(int... varargs1,int... varargs2){} (不合法)
3：如果使用对象的不定长参数，声明的方法相同，例如：
public void someMethod(someClass... somes){}
以上就是我所知道的不定长参数的相关知识，在这里献丑了……
如果有高人了解的更多，我愿闻其详……
最后，祝所有和我一样在自学java的兄弟们，早日出头……
这是lambda表达式, 一种语法(糖) ,可以简化代码,从java8开始支持lambda表达式.
有的编程语言,很多早就有lambda表达式了, java从8才开始支持lambda表达式,算比较晚的了.
我们以实现Runabble接口,来创建一个线程为例
一: 使用传统的匿名内部类来实现,
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类的方式实现Runnable接口");
}
});
t1.start();
很多人觉得上面的写法比较啰嗦, 写那么多代码, 核心就是一句System.out.println("....")
二: lambda表达式实现
Thread t2 = new Thread(() - {System.out.println("lambda表达式的实现Runabble接口");});
t2.start();
lambda表示配合Java8流, 进行函数式编程, 可以简洁的完成很多比较啰嗦的逻辑 .
比如对一个ListDouble进行求和,求均值,求最大值,求最小值,元素个数. 以前需要写较多的代码.
Java8流和lambda表达式的操作方法如下
// lambda表达式配合java8流
ListDouble list = Arrays.asList(5.9, 4.5, 6.2, 1.8, 3.7, 2.9, 2.52);
DoubleSummaryStatistics ds = list.stream().collect(Collectors.summarizingDouble(x - x));
System.out.println("最小值:" + ds.getMin());
System.out.println("最大值:" + ds.getMax());
System.out.println("平均值:" + ds.getAverage());
// System.out.println("数量:" + ds.getCount());
// System.out.println("总和:" + ds.getSum());
相关的知识, 还是比较多, 建议先学习lambda表达式,然后学习java8流(stream)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Recipe {
private String name; //菜谱名称
private String style; //菜系 如：川菜、湘菜等
private int time; //烹饪时长 分钟
private String[] food; //食材
private String[] step; //操作步骤
public Recipe() {
}
public Recipe(String name, String style, int time, String[] food, String[] step) {
this.name = name;
this.style = style;
this.time = time;
this.food = food;
this.step = step;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStyle() {
return style;
}
public void setStyle(String style) {
this.style = style;
}
public int getTime() {
return time;
}
public void setTime(int time) {
this.time = time;
}
public String[] getFood() {
return food;
}
public void setFood(String[] food) {
this.food = food;
}
public String[] getStep() {
return step;
}
public void setStep(String[] step) {
this.step = step;
}
@Override
public String toString() {
String foods="";
for (String f : food) {
foods+=f+" ";
}
String steps="";
for (int i = 0; i step.length; i++) {
steps += (i+1)+"."+step[i];
if(i!=step.length-1){
steps+=";";
}
}
return "菜谱名称：" + name +
"\n菜系：" + style +
"\n时长：" + time +
"\n所需食材：" + foods +
"\n操作步骤：" + steps;
}
public static void print(Recipe[] recipes){
for (Recipe recipe : recipes) {
System.out.println(recipe);
}
}
public static Recipe[] searchRecipesContainName(Recipe[] recipes, String name){
ListRecipe list=new ArrayListRecipe();
for (Recipe recipe : recipes) {
if(recipe.getName().contains(name)){
list.add(recipe);
}
}
return list.toArray(new Recipe[list.size()]);
}
public static Recipe[] searchRecipes(Recipe[] recipes, String style){
ListRecipe list=new ArrayListRecipe();
for (Recipe recipe : recipes) {
if(recipe.getStyle().equals(style)){
list.add(recipe);
}
}
return list.toArray(new Recipe[list.size()]);
}
public static Recipe[] searchRecipeLessThan(Recipe[] recipes, int time){
ListRecipe list=new ArrayListRecipe();
for (Recipe recipe : recipes) {
if(recipe.getTime()time){
list.add(recipe);
}
}
return list.toArray(new Recipe[list.size()]);
}
public static Recipe[] searchRecipeContainsFood(Recipe[] recipes, String food){
ListRecipe list=new ArrayListRecipe();
for (Recipe recipe : recipes) {
for (String s : recipe.getFood()) {
if(s.equals(food)){
list.add(recipe);
}
}
}
return list.toArray(new Recipe[list.size()]);
}
public static void main(String[] args) {
//存储5个菜谱的信息
Recipe[] recipes=new Recipe[5];
recipes[0]=new Recipe("酱牛肉","家常菜",120,
new String[]{
"牛腱子",
"黄豆酱油",
"黄酒",
"冰糖"
},
new String[]{
"准备好主要食材",
"加入食材慢炖两至三小时"
});
recipes[1]=new Recipe("红烧牛肉","家常菜",120,
new String[]{
"牛腩",
"牛筋",
"生抽",
"冰糖"
},new String[]{
"准备好主要食材",
"加入食材慢炖两至三小时"
});
recipes[2]=new Recipe("小鸡炖蘑菇","湘菜",100,
new String[]{
"小鸡",
"蘑菇"
},
new String[]{
"准备好主要食材",
"加入食材慢炖两至三小时"
});
recipes[3]=new Recipe("地三鲜","川菜",25,
new String[]{
"茄子",
"辣椒"
},
new String[]{
"准备好主要食材",
"加入食材慢炖"
});
recipes[4]=new Recipe("西红柿","湘菜",20,
new String[]{
"西红柿",
"味达美酱油"
},
new String[]{
"准备好主要食材",
"加入食材慢炖"
});
System.out.println("找到所有名称中包含牛肉的菜谱:");
Recipe[] result_1 = searchRecipesContainName(recipes, "牛肉");
print(result_1);
System.out.println("\n希望查找所有湘菜的菜谱:");
Recipe[] result_2=searchRecipes(recipes,"湘菜");
print(result_2);
System.out.println("\n查找烹饪时长小于30分钟的菜谱:");
Recipe[] result_3=searchRecipeLessThan(recipes,30);
print(result_3);
System.out.println("\n查找包含西红柿的菜谱:");
Recipe[] result_4=searchRecipeContainsFood(recipes,"西红柿");
print(result_4);
}
}
初步做了一个出来，但是效率并不是很高，前100个计算速度还可以，但是往后就很慢了。如果什么时候有空的话可以再看看，先给你代码吧，不知道能不能帮上你
public class AlisandaNumber {
private static final int MAX_INDEX = 1000; // 可以先把这个常量改为1-6，验证正确性
public static void main(String[] args) {
int a = 0;
int index = 0;
while(index MAX_INDEX) {
a += 6; // 每次循环自增6，由题目规律可知A是6的倍数
boolean breakOut = false;
// 最大的约数为此数的平方根，因为如果是两个平方根相乘的话，剩下的就只有1了
int maxNum = (int) Math.ceil(Math.sqrt(a));
p:
for(int p = 1; p = maxNum; p ++) {
if(a % p != 0) {
continue; // 如果不是约数的话，没必要考虑，下同
}
// 最大约数为平方根的相反数，原理同上
maxNum = (int) Math.ceil(Math.sqrt(a / p));
for(int q = -1; q = -maxNum; q --) { // q和r必为负数
if(a % q != 0) {
continue;
}
int r = a / (p * q);
int nonZero = p * q + p * r + q * r;
if (nonZero == 0) {
continue;
}
if((a == p * q * r) (a == (p * q * r) / (nonZero))) {
index ++;
breakOut = true;
break p; // 跳出外层循环
}
}
}
if(breakOut) {
System.out.println(String.format("第%d个压力山大数是%d", index, a));
}
}
}
}