嘉兴网嘉兴网站建设,类似钉钉的企业管理软件,做电销有什么资料网站,大连华南网站制作公司一、Set系列集合
1.1 认识Set集合的特点
Set集合是属于Collection体系下的另一个分支#xff0c;它的特点如下图所示 下面我们用代码简单演示一下#xff0c;每一种Set集合的特点。
//SetInteger set new HashSet(); //无序、无索引、不重复
//Set…
一、Set系列集合
1.1 认识Set集合的特点
Set集合是属于Collection体系下的另一个分支它的特点如下图所示 下面我们用代码简单演示一下每一种Set集合的特点。
//SetInteger set new HashSet(); //无序、无索引、不重复
//SetInteger set new LinkedHashSet(); //有序、无索引、不重复
SetInteger set new TreeSet(); //可排序(升序)、无索引、不重复
set.add(666);
set.add(555);
set.add(555);
set.add(888);
set.add(888);
set.add(777);
set.add(777);
System.out.println(set); //[555, 666, 777, 888] 1.2 HashSet集合底层原理
HashSet集合底层是基于哈希表实现的哈希表根据JDK版本的不同也是有点区别的 JDK8以前哈希表 数组链表 JDK8以后哈希表 数组链表红黑树 我们发现往HashSet集合中存储元素时底层调用了元素的两个方法一个是hashCode方法获取元素的hashCode值哈希值另一个是调用了元素的equals方法用来比较新添加的元素和集合中已有的元素是否相同。 只有新添加元素的hashCode值和集合中以后元素的hashCode值相同、新添加的元素调用equals方法和集合中已有元素比较结果为true, 才认为元素重复。 如果hashCode值相同equals比较不同则以链表的形式连接在数组的同一个索引为位置如上图所示
在JDK8开始后为了提高性能当链表的长度超过8时就会把链表转换为红黑树如下图所示 1.3 HashSet去重原理
HashSet存储元素的原理依赖于两个方法一个是hashCode方法用来确定在底层数组中存储的位置另一个是用equals方法判断新添加的元素是否和集合中已有的元素相同。
要想保证在HashSet集合中没有重复元素我们需要重写元素类的hashCode和equals方法。比如以下面的Student类为例假设把Student类的对象作为HashSet集合的元素想要让学生的姓名和年龄相同就认为元素重复。
public class Student{private String name; //姓名private int age; //年龄private double height; //身高//无参数构造方法public Student(){}//全参数构造方法public Student(String name, int age, double height){this.namename;this.ageage;this.heightheight;}//...get、set、toString()方法自己补上..//按快捷键生成hashCode和equals方法//altinsert 选择 hashCode and equalsOverridepublic boolean equals(Object o) {if (this o) return true;if (o null || getClass() ! o.getClass()) return false;
Student student (Student) o;
if (age ! student.age) return false;if (Double.compare(student.height, height) ! 0) return false;return name ! null ? name.equals(student.name) : student.name null;}
Overridepublic int hashCode() {int result;long temp;result name ! null ? name.hashCode() : 0;result 31 * result age;temp Double.doubleToLongBits(height);result 31 * result (int) (temp ^ (temp 32));return result;}
}
接着写一个测试类往HashSet集合中存储Student对象。
public class Test{public static void main(String[] args){SetStudent students new HashSet();Student s1 new Student(至尊宝,20, 169.6);Student s2 new Student(蜘蛛精,23, 169.6);Student s3 new Student(蜘蛛精,23, 169.6);Student s4 new Student(牛魔王,48, 169.6);students.add(s1);students.add(s2);students.add(s3);students.add(s4);for(Student s : students){System.out.println(s);}}
}
打印结果如下我们发现存了两个蜘蛛精当时实际打印出来只有一个而且是无序的。
Student{name牛魔王, age48, height169.6}
Student{name至尊宝, age20, height169.6}
Student{name蜘蛛精, age23, height169.6} 1.4 LinkedHashSet底层原理
LinkedHashSet它底层采用的是也是哈希表结构只不过额外新增了一个双向链表来维护元素的存取顺序。如下下图所示 每次添加元素就和上一个元素用双向链表连接一下。第一个添加的元素是双向链表的头节点最后一个添加的元素是双向链表的尾节点。
把上个案例中的集合改成LinkedList集合我们观察效果怎样
public class Test{public static void main(String[] args){SetStudent students new LinkedHashSet();Student s1 new Student(至尊宝,20, 169.6);Student s2 new Student(蜘蛛精,23, 169.6);Student s3 new Student(蜘蛛精,23, 169.6);Student s4 new Student(牛魔王,48, 169.6);students.add(s1);students.add(s2);students.add(s3);students.add(s4);for(Student s : students){System.out.println(s);}}
}
打印结果如下Student{name至尊宝, age20, height169.6}
Student{name蜘蛛精, age23, height169.6}
Student{name牛魔王, age48, height169.6} 1.5 TreeSet集合
TreeSet集合的特点是可以对元素进行排序但是必须指定元素的排序规则。
如果往集合中存储String类型的元素或者Integer类型的元素它们本身就具备排序规则所以直接就可以排序。
SetInteger set1 new TreeSet();
set1.add(8);
set1.add(6);
set1.add(4);
set1.add(3);
set1.add(7);
set1.add(1);
set1.add(5);
set1.add(2);
System.out.println(set1); //[1,2,3,4,5,6,7,8]
SetInteger set2 new TreeSet();
set2.add(a);
set2.add(c);
set2.add(e);
set2.add(b);
set2.add(d);
set2.add(f);
set2.add(g);
System.out.println(set1); //[a,b,c,d,e,f,g] 如果往TreeSet集合中存储自定义类型的元素比如说Student类型则需要我们自己指定排序规则否则会出现异常。
//创建TreeSet集合元素为Student类型
SetStudent students new TreeSet();
//创建4个Student对象
Student s1 new Student(至尊宝,20, 169.6);
Student s2 new Student(紫霞,23, 169.8);
Student s3 new Student(蜘蛛精,23, 169.6);
Student s4 new Student(牛魔王,48, 169.6);
//添加Studnet对象到集合
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
System.out.println(students);
此时运行代码会直接报错。原因是TreeSet不知道按照什么条件对Student对象来排序。 我们想要告诉TreeSet集合按照指定的规则排序有两种办法 第一种让元素的类实现Comparable接口重写compareTo方法 第二种在创建TreeSet集合时通过构造方法传递Compartor比较器对象 排序方式1我们先来演示第一种排序方式
//第一步先让Student类实现Comparable接口
//注意Student类的对象是作为TreeSet集合的元素的
public class Student implements ComparableStudent{private String name;private int age;private double height;//无参数构造方法public Student(){}//全参数构造方法public Student(String name, int age, double height){this.namename;this.ageage;this.heightheight;}//...get、set、toString()方法自己补上..//第二步重写compareTo方法//按照年龄进行比较只需要在方法中让this.age和o.age相减就可以。/*原理在往TreeSet集合中添加元素时add方法底层会调用compareTo方法根据该方法的结果是正数、负数、还是零决定元素放在后面、前面还是不存。*/Overridepublic int compareTo(Student o) {//this表示将要添加进去的Student对象//o: 表示集合中已有的Student对象return this.age-o.age;}
}
此时再运行测试类结果如下
Student{name至尊宝, age20, height169.6}
Student{name紫霞, age20, height169.8}
Student{name蜘蛛精, age23, height169.6}
Student{name牛魔王, age48, height169.6} 排序方式2接下来演示第二种排序方式
//创建TreeSet集合时传递比较器对象排序
/*
原理当调用add方法时底层会先用比较器根据Comparator的compare方是正数、负数、还是零决定谁在后谁在前谁不存。
*/
//下面代码中是按照学生的年龄升序排序
SetStudent students new TreeSet(new ComparatorStudent{Overridepublic int compare(Student o1, Student o2){//需求按照学生的身高排序return Double.compare(o1,o2); }
});
//创建4个Student对象
Student s1 new Student(至尊宝,20, 169.6);
Student s2 new Student(紫霞,23, 169.8);
Student s3 new Student(蜘蛛精,23, 169.6);
Student s4 new Student(牛魔王,48, 169.6);
//添加Studnet对象到集合
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
System.out.println(students);
1.6 总结Collection集合 1.7 并发修改异常
使用迭代器遍历集合时可能存在并发修改异常。
我们先把这个异常用代码演示出来再解释一下为什么会有这个异常产生
ListString list new ArrayList();
list.add(王麻子);
list.add(小李子);
list.add(李爱花);
list.add(张全蛋);
list.add(晓李);
list.add(李玉刚);
System.out.println(list); // [王麻子, 小李子, 李爱花, 张全蛋, 晓李, 李玉刚]
//需求找出集合中带李字的姓名并从集合中删除
IteratorString it list.iterator();
while(it.hasNext()){String name it.next();if(name.contains(李)){list.remove(name);}
}
System.out.println(list);
运行上面的代码会出现下面的异常。这就是并发修改异常 为什么会出现这个异常呢那是因为迭代器遍历机制规定迭代器遍历集合的同时不允许集合自己去增删元素否则就会出现这个异常。
怎么解决这个问题呢不使用集合的删除方法而是使用迭代器的删除方法代码如下
ListString list new ArrayList();
list.add(王麻子);
list.add(小李子);
list.add(李爱花);
list.add(张全蛋);
list.add(晓李);
list.add(李玉刚);
System.out.println(list); // [王麻子, 小李子, 李爱花, 张全蛋, 晓李, 李玉刚]
//需求找出集合中带李字的姓名并从集合中删除
IteratorString it list.iterator();
while(it.hasNext()){String name it.next();if(name.contains(李)){//list.remove(name);it.remove(); //当前迭代器指向谁就删除谁}
}
System.out.println(list); 二、Collection的其他操作
2.1 可变参数
关于可变参数我们首先要知道它是什么然后要知道它的本质。搞清楚这两个问题可变参数就算你学明白了。 可变参数是一种特殊的形式参数定义在方法、构造器的形参列表处它可以让方法接收多个同类型的实际参数。 可变参数在方法内部本质上是一个数组 2.2 Collections工具类
有了可变参数的基础我们再学习Collections这个工具类就好理解了因为这个工具类的方法中会用到可变参数。
注意Collections并不是集合它比Collection多了一个s一般后缀为s的类很多都是工具类。这里的Collections是用来操作Collection的工具类。它提供了一些好用的静态方法如下 我们把这些方法用代码来演示一下
public class CollectionsTest{public static void main(String[] args){//1.public static T boolean addAll(Collection? super T c, T...e)ListString names new ArrayList();Collections.addAll(names, 张三,王五,李四, 张麻子);System.out.println(names);//2.public static void shuffle(List? list)对集合打乱顺序Collections.shuffle(names);System.out.println(names);//3.public static T void short(ListT list): 对List集合排序ListInteger list new ArrayList();list.add(3);list.add(5);list.add(2);Collections.sort(list);System.out.println(list);}
}
上面我们往集合中存储的元素要么是Stirng类型要么是Integer类型他们本来就有一种自然顺序所以可以直接排序。但是如果我们往List集合中存储Student对象这个时候想要对List集合进行排序自定义比较规则的。指定排序规则有两种方式如下 排序方式1让元素实现Comparable接口重写compareTo方法 比如现在想要往集合中存储Studdent对象首先需要准备一个Student类实现Comparable接口。
public class Student implements ComparableStudent{private String name;private int age;private double height;//排序时底层会自动调用此方法this和o表示需要比较的两个对象Overridepublic int compareTo(Student o){//需求按照年龄升序排序//如果返回正数说明左边对象的年龄右边对象的年龄//如果返回负数说明左边对象的年龄右边对象的年龄//如果返回0说明左边对象的年龄和右边对象的年龄相同return this.age - o.age;}//...getter、setter、constructor..
}
然后再使用Collections.sort(list集合)对List集合排序如下
//3.public static T void short(ListT list): 对List集合排序
ListStudent students new ArrayList();
students.add(new Student(蜘蛛精,23,169.7));
students.add(new Student(紫霞,22,169.8));
students.add(new Student(紫霞,22,169.8));
students.add(new Student(至尊宝,26,169.5));
/*
原理sort方法底层会遍历students集合中的每一个元素采用排序算法将任意两个元素两两比较每次比较时会用一个Student对象调用compareTo方法和另一个Student对象进行比较根据compareTo方法返回的结果是正数、负数零来决定谁大谁小谁相等重新排序元素的位置注意这些都是sort方法底层自动完成的想要完全理解必须要懂排序算法才行
*/
Collections.sort(students);
System.out.println(students); 排序方式2使用调用sort方法是传递比较器 /*
原理sort方法底层会遍历students集合中的每一个元素采用排序算法将任意两个元素两两比较每次比较会将比较的两个元素传递给Comparator比较器对象的compare方法的两个参数o1和o2,根据compare方法的返回结果是正数负数或者0来决定谁大谁小谁相等重新排序元素的位置注意这些都是sort方法底层自动完成的不需要我们完全理解想要理解它必须要懂排序算法才行.
*/
Collections.sort(students, new ComparatorStudent(){Overridepublic int compare(Student o1, Student o2){return o1.getAge()-o2.getAge();}
});
System.out.println(students); 2.3 斗地主案例 我们先分析一下业务需求 总共有54张牌每一张牌有花色和点数两个属性、为了排序还可以再加一个序号 点数可以是“3”,4,5,6,7,8,9,10,J,Q,K,A,2 花色可以是“♣”,♠,♥,♦ 斗地主时三个玩家没人手里17张牌剩余3张牌作为底牌
第一步为了表示每一张牌有哪些属性首先应该新建一个扑克牌的类
第二步启动游戏时就应该提前准备好54张牌
第三步接着再完全洗牌、发牌、捋牌、看牌的业务逻辑 先来完成第一步定义一个扑克类Card public class Card {private String number;private String color;// 每张牌是存在大小的。private int size; // 0 1 2 ....
public Card() {}
public Card(String number, String color, int size) {this.number number;this.color color;this.size size;}
public String getNumber() {return number;}
public void setNumber(String number) {this.number number;}
public String getColor() {return color;}
public void setColor(String color) {this.color color;}
public int getSize() {return size;}
public void setSize(int size) {this.size size;}
Overridepublic String toString() {return color number ;}
} 再完成第二步定义一个房间类初始化房间时准备好54张牌 public class Room {// 必须有一副牌。private ListCard allCards new ArrayList();
public Room(){// 1、做出54张牌存入到集合allCards// a、点数个数确定了类型确定。String[] numbers {3,4,5,6,7,8,9,10,J,Q,K,A,2};// b、花色个数确定了类型确定。String[] colors {♠, ♥, ♣, ♦};int size 0; // 表示每张牌的大小// c、遍历点数再遍历花色组织牌for (String number : numbers) {// number 3size; // 1 2 ....for (String color : colors) {// 得到一张牌Card c new Card(number, color, size);allCards.add(c); // 存入了牌}}// 单独存入小大王的。Card c1 new Card(, , size);Card c2 new Card(, , size);Collections.addAll(allCards, c1, c2);System.out.println(新牌 allCards);}
} 最后完成第三步定义一个启动游戏的方法完成洗牌、发牌、捋牌、看牌的业务逻辑 /**
* 游戏启动
*/
public void start() {// 1、洗牌 allCardsCollections.shuffle(allCards);System.out.println(洗牌后 allCards);
// 2、发牌首先肯定要定义 三个玩家。 List(ArrayList) Set(TreeSet)ListCard linHuChong new ArrayList();ListCard jiuMoZhi new ArrayList();ListCard renYingYing new ArrayList();// 正式发牌给这三个玩家依次发出51张牌剩余3张做为底牌。// allCards [♥3, ♣10, ♣4, ♥K, ♦Q, ♣2, , ♣8, ....// 0 1 2 3 4 5 6 ... % 3for (int i 0; i allCards.size() - 3; i) {Card c allCards.get(i);// 判断牌发给谁if(i % 3 0){// 请啊冲接牌linHuChong.add(c);}else if(i % 3 1){// 请啊鸠来接牌jiuMoZhi.add(c);}else if(i % 3 2){// 请盈盈接牌renYingYing.add(c);}}
// 3、对3个玩家的牌进行排序sortCards(linHuChong);sortCards(jiuMoZhi);sortCards(renYingYing);// 4、看牌System.out.println(啊冲 linHuChong);System.out.println(啊鸠 jiuMoZhi);System.out.println(盈盈 renYingYing);ListCard lastThreeCards allCards.subList(allCards.size() - 3, allCards.size()); // 51 52 53System.out.println(底牌 lastThreeCards);jiuMoZhi.addAll(lastThreeCards);sortCards(jiuMoZhi);System.out.println(啊鸠抢到地主后 jiuMoZhi);
}
/*** 集中进行排序* param cards*/
private void sortCards(ListCard cards) {Collections.sort(cards, new ComparatorCard() {Overridepublic int compare(Card o1, Card o2) {// return o1.getSize() - o2.getSize(); // 升序排序return o2.getSize() - o1.getSize(); // 降序排序}});
}
不要忘记了写测试类了
public class GameDemo {public static void main(String[] args) {// 1、牌类。// 2、房间Room m new Room();// 3、启动游戏m.start();}
} 三、Map集合
3.1 Map概述体系
所谓双列集合就是说集合中的元素是一对一对的。Map集合中的每一个元素是以keyvalue的形式存在的一个keyvalue就称之为一个键值对而且在Java中有一个类叫Entry类Entry的对象用来表示键值对对象。
所有的Map集合有如下的特点键不能重复值可以重复每一个键只能找到自己对应的值。 下面我们先写一个Map集合保存几个键值对体验一下Map集合的特点
public class MapTest1 {public static void main(String[] args) {// MapString, Integer map new HashMap(); // 一行经典代码。 按照键 无序不重复无索引。MapString, Integer map new LinkedHashMap(); // 有序不重复无索引。map.put(手表, 100);map.put(手表, 220); // 后面重复的数据会覆盖前面的数据键map.put(手机, 2);map.put(Java, 2);map.put(null, null);System.out.println(map);
MapInteger, String map1 new TreeMap(); // 可排序不重复无索引map1.put(23, Java);map1.put(23, MySQL);map1.put(19, 李四);map1.put(20, 王五);System.out.println(map1);}
}
Map集合也有很多种在Java中使用不同的类来表示的每一种Map集合其键的特点是有些差异的值是键的一个附属值所以我们只关注键的特点就可以了。 3.2 Map集合的常用方法
由于Map是所有双列集合的父接口所以我们只需要学习Map接口中每一个方法是什么含义那么所有的Map集合方法你就都会用了。 public class MapTest2 {public static void main(String[] args) {// 1.添加元素: 无序不重复无索引。MapString, Integer map new HashMap();map.put(手表, 100);map.put(手表, 220);map.put(手机, 2);map.put(Java, 2);map.put(null, null);System.out.println(map);// map {nullnull, 手表220, Java2, 手机2}
// 2.public int size():获取集合的大小System.out.println(map.size());
// 3、public void clear():清空集合//map.clear();//System.out.println(map);
// 4.public boolean isEmpty(): 判断集合是否为空为空返回true ,反之System.out.println(map.isEmpty());
// 5.public V get(Object key)根据键获取对应值int v1 map.get(手表);System.out.println(v1);System.out.println(map.get(手机)); // 2System.out.println(map.get(张三)); // null
// 6. public V remove(Object key)根据键删除整个元素(删除键会返回键的值)System.out.println(map.remove(手表));System.out.println(map);
// 7.public boolean containsKey(Object key): 判断是否包含某个键 包含返回true ,反之System.out.println(map.containsKey(手表)); // falseSystem.out.println(map.containsKey(手机)); // trueSystem.out.println(map.containsKey(java)); // falseSystem.out.println(map.containsKey(Java)); // true
// 8.public boolean containsValue(Object value): 判断是否包含某个值。System.out.println(map.containsValue(2)); // trueSystem.out.println(map.containsValue(2)); // false
// 9.public SetK keySet(): 获取Map集合的全部键。SetString keys map.keySet();System.out.println(keys);
// 10.public CollectionV values(); 获取Map集合的全部值。CollectionInteger values map.values();System.out.println(values);
// 11.把其他Map集合的数据倒入到自己集合中来。(拓展)MapString, Integer map1 new HashMap();map1.put(java1, 10);map1.put(java2, 20);MapString, Integer map2 new HashMap();map2.put(java3, 10);map2.put(java2, 222);map1.putAll(map2); // putAll把map2集合中的元素全部倒入一份到map1集合中去。System.out.println(map1);System.out.println(map2);}
}
3.3 Map集合遍历方式1
Map集合一共有三种遍历方式我们先来学习第一种他需要用到下面的两个方法 /*** 目标掌握Map集合的遍历方式1键找值*/
public class MapTest1 {public static void main(String[] args) {// 准备一个Map集合。MapString, Double map new HashMap();map.put(蜘蛛精, 162.5);map.put(蜘蛛精, 169.8);map.put(紫霞, 165.8);map.put(至尊宝, 169.5);map.put(牛魔王, 183.6);System.out.println(map);// map {蜘蛛精169.8, 牛魔王183.6, 至尊宝169.5, 紫霞165.8}
// 1、获取Map集合的全部键SetString keys map.keySet();// System.out.println(keys);// [蜘蛛精, 牛魔王, 至尊宝, 紫霞]// key// 2、遍历全部的键根据键获取其对应的值for (String key : keys) {// 根据键获取对应的值double value map.get(key);System.out.println(key value);}}
}
3.4 Map集合遍历方式2
这里Map集合的第二种方式是直接获取每一个Entry对象把Entry存储扫Set集合中去再通过Entry对象获取键和值。 /*** 目标掌握Map集合的第二种遍历方式键值对。*/
public class MapTest2 {public static void main(String[] args) {MapString, Double map new HashMap();map.put(蜘蛛精, 169.8);map.put(紫霞, 165.8);map.put(至尊宝, 169.5);map.put(牛魔王, 183.6);System.out.println(map);// map {蜘蛛精169.8, 牛魔王183.6, 至尊宝169.5, 紫霞165.8}// entries [(蜘蛛精169.8), (牛魔王183.6), (至尊宝169.5), (紫霞165.8)]// entry (蜘蛛精169.8)// entry (牛魔王183.6)// ...// 1、调用Map集合提供entrySet方法把Map集合转换成键值对类型的Set集合SetMap.EntryString, Double entries map.entrySet();for (Map.EntryString, Double entry : entries) {String key entry.getKey();double value entry.getValue();System.out.println(key ---- value);}}
} 3.5 Map集合遍历方式3
Map集合的第三种遍历方式需要用到下面的一个方法forEach而这个方法是JDK8版本以后才有的。调用起来非常简单最好是结合的lambda表达式一起使用。 /*** 目标掌握Map集合的第二种遍历方式键值对。*/
public class MapTest3 {public static void main(String[] args) {MapString, Double map new HashMap();map.put(蜘蛛精, 169.8);map.put(紫霞, 165.8);map.put(至尊宝, 169.5);map.put(牛魔王, 183.6);System.out.println(map);// map {蜘蛛精169.8, 牛魔王183.6, 至尊宝169.5, 紫霞165.8}
//遍历map集合传递匿名内部类map.forEach(new BiConsumerString, Double() {Overridepublic void accept(String k, Double v) {System.out.println(k ---- v);}});//遍历map集合传递Lambda表达式map.forEach(( k, v) - {System.out.println(k ---- v);});}
} 3.6 Map集合案例
学习完Map集合的基本用法之后接下来我们做一个综合案例将Map集合运用一下。 先分析需求再考虑怎么用代码实现 1.首先可以将80个学生选择的景点放到一个集合中去也就是说集合中的元素是80个任意的ABCD元素
2.准备一个Map集合用来存储景点以及景点被选择的次数
3.遍历80个学生选择景点的集合得到每一个景点判断Map集合中是否包含该景点如果不包含则存储景点1如果包含则存获取该景点原先的值再存储景点原来的值1; 此时新值会覆盖旧值 /*** 目标完成Map集合的案例统计投票人数。*/
public class MapDemo4 {public static void main(String[] args) {// 1、把80个学生选择的景点数据拿到程序中来。ListString data new ArrayList();String[] selects {A, B, C, D};Random r new Random();for (int i 1; i 80; i) {// 每次模拟一个学生选择一个景点存入到集合中去。int index r.nextInt(4); // 0 1 2 3data.add(selects[index]);}System.out.println(data);
// 2、开始统计每个景点的投票人数// 准备一个Map集合用于统计最终的结果MapString, Integer result new HashMap();
// 3、开始遍历80个景点数据for (String s : data) {// 问问Map集合中是否存在该景点if(result.containsKey(s)){// 说明这个景点之前统计过。其值1. 存入到Map集合中去result.put(s, result.get(s) 1);}else {// 说明这个景点是第一次统计存入景点1result.put(s, 1);}}System.out.println(result);}
}
