269/270LinkedHashset集合和可变参数

LinkedHashSet集合

哈希表和链表实现的Set接口， 具有可预测的迭代次序;

由链表保证元素有序，也就是说元素的存储和取出顺序是一致的;

由哈希表保证元素唯一， 也就是说没有重复的元素;

LinkedHashSet是HashSet的子类
LinkedHashSet底层是一个LinkedHashMap，底层维护了一个 数组+双向链表
LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的
LinkedHashSet不允许添加重复元素

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢?

在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

java.utiL.LinkedHashset集合extends Hashset集合LinkedHashset集合特点:

底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序

 public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add( "www" );
        set.add( "abc" );
        set.add( "abc" );
        set.add( "itcast" );
        System.out.println(set);//无序,不允许重复
        
        
        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add( "www" );
        linked.add("abc");
        linked.add("abc");
        linked.add( "itcast" );
        System.out.println(linked);//有序,不允许重复
    }



public class LinkedHashT {
    public static void main(String[] args) {
        //创建一个LinkedHashSet集合：
        LinkedHashSet<Integer> lhs = new LinkedHashSet<>();
        System.out.println(lhs.add(9));//true
        lhs.add(5);
        lhs.add(8);
        System.out.println(lhs.add(9));//false 这个9没有放入到集合中
        lhs.add(6);
        System.out.println(lhs.size());//4 唯一，有序
        System.out.println(lhs); //[9, 5, 8, 6]
    }
}

 

HashSet<String> set = new HashSet<>();
set.add("www");
set.add("www");
set.add("ww");
set.add("w");
System.out.println(set);   //[ww,www,w]无序且不允许重复
 
 
 
LinkedHashSet<String> linked = new LinkedHashSet<>();
linked.add("www");
linked.add("www");
linked.add("ww");
linked.add("w");
System.out.println(linked);   //[www,ww,w]有序且不允许重复

 

 

可变参数

概念

可变参数(variable argument)允许你指定可以采用多个同类型参数的方法，而不需要事先确定参数的数目。

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化

格式:

　　修饰符   返回值类型     方法名(参数类型..．形参名){}

其实这个书写完全等价与

　　修饰符    返回值类型      方法名(参数类型门]形参名){}

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

JDK1.5以后。出现了简化操作。...用在参数上，称之为可变参数。
　　同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，白动完成了

 

可变参数:是JDK1.5之后出现的新特性

使用前提:

　　当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数．

使用格式:定义方法时使用

　　修饰符返       回值类型          方法名(数据类型...变量名){}

可变参数的原理:

　　可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数

　　传递的参数个数,可以是o个(不传递),1,2...多个

 

定义方法

在定义方法时，在最后一个形参后加上三点“…“，就表示该形参可以接受多个参数值，多个参数值被当成数组传入。上述定义有几个要点需要注意：

    可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数

    由于可变参数必须是最后一个参数，所以一个函数最多只能有一个可变参数

    Java的可变参数，会被编译器转型为一个数组

    变长参数在编译为字节码后，在方法签名中就是以数组形态出现的。这两个方法的签名是一致的，不能作为方法的重载。如果同时出现，是不能编译通过的。可变参数可以兼容数组，反之则不成立

public void foo(String...varargs){}

foo("arg1", "arg2", "arg3");

//上述过程和下面的调用是等价的
foo(new String[]{"arg1", "arg2", "arg3"});

 

 

public static void main(String[] args) {
        /*
            定义计算(0-n)整数和的方法
            已知:计算整数的和,数据类型已经确定int
            但是参数的个数不确定,不知道要计算几个整数的和,就可以使用可变参数
            public static int add(int. . .arr){
            }
            //定义一个方法,计算三个int类型整数的和
            */
        int i =  add(12,12);
        System.out.println(i);
    }
    public static  int add(int...arr){
//        System.out.println(arr);
//        System.out.println(arr.length);
        int num = 0;
        for (int i :arr){
            num+=i;
        }
        return num;
    }

//        public static int add(int a,int b,int c){
//            return a+b+c;
//           }
//        //定义一个方法,计算两个int类型整数的和
//        public static int add (int a,int b) {
//            


 

package com.zhong.method;

public class Demo04{     
       public static void main(String  args[]) {
            //调用可变参数的方法
            printMax(...numbers:34,3,3,2,56.5);
            printMax(new double[]{1,2,3});
       }
       
    public static void printMax(double... numbers){  
    //double...  就是声明方法 参数类型。  numbers 就是可变参数                      
        if(numbers.length==0) {   //可变参数的长度等于0
           System.out.println("No argument passed");
           return;
       }
       double result = numbers[0];  //返回值result；numbers[0]是数组。
       //排序！
       for (int i = 1;i < numbers,length; i++){
          if (numbers[i]>result){
              result = numbers[i];
            }
         }
        System.out.println("The max value is" + result);
    }


 

package com.zhong.method;

  public class Demo04 {     
       public static void main(String [] args){
           Demo04 demo04 = new Demo04(); //新建一个类返回当前对象
           demo04.tset(x:1,...i:1,2,3,4,5,90); //这就是数值
       }
          public void test(int x,int... i){//可变参数 i
                 System.out.println(0);
                 System.out.println(1);
                 System.out.println(2);
                 System.out.println(3);
                 System.out.println(4);
                 System.out.println(5);
          }
            Scanner scanner = new Scanner(System.in);
            System.out.println("hello,world!");
       scanner.close();
     }
}