• ------- android培训、java培训、期待与您交流! ---------- Java基础语法 1.1Java语言基础(选择结构switch语句的格式及其解释)(掌握)  A:switch语句的格式  switch(表达式){  case 值1:  

    ------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流! ----------

    Java基础语法

    1.1Java语言基础(选择结构switch语句的格式及其解释)(掌握)
             A:switch语句的格式
                       switch(表达式){
                                case 值1:
                                         语句体1;
                                         break;
                                case 值2:
                                         语句体2;
                                         break;
                                case 值3:
                                         语句体3;
                                         break;
                                ....
                                default:
                                         语句体n+1;
                                         break;
                       }
             B:switch语句的格式解释
                       (1):switch表示这是switch语句
                                ☆表达式的取值:byte,short,int,char
                                   JDK5以后可以是枚举(什么是枚举,以后再讲)
                                   JDK7以后可以是String
                       (2):case后面跟的是要和表达式进行比较的值
                       (3):语句体部分可以是一条或多条语句
                       (4):break表示中断,结束的意思,可以结束switch语句
                       (5):default语句表示所有情况都不匹配的时候,就执行该处的内容,和if语句的else相似
            
             C:执行流程
                       先计算表达式的值
                       然后和case后面的匹配,如果匹配成功就执行对应的语句,遇到break就会结束,否则执行default控制的语句
    1.2Java语言基础(选择结构switch语句的基本使用)
    1.3Java语言基础(选择结构switch语句的注意事项)(掌握)

    A:案例演示

                       a:case后面只能是常量,不能是变量,而且,多个case后面的值不能出现相同的

                       b:default可以省略吗?

                                可以省略,但是不建议,因为它的作用是对不正确的情况给出提示。

                       c:break可以省略吗?

                                可以省略,但是结果可能不是我们想要的。

                                会出现一个现象:case穿透。

                                最终我们建议不要省略

                       d:default一定要在最后吗?

                                不是,可以在任意位置。但是建议在最后。

                       e:switch语句的结束条件

                                a:遇到break就结束了

                                b:执行到末尾就结束了

    1.4Java语言基础(选择结构switch语句练习)

             A:看程序写结果:

                       intx = 2;

                      int y = 3;

                       switch(x){

                                default:

                                         y++;

                                         break;

                                case3:

                                         y++;

                                case4:

                                         y++;

                       }

                       System.out.println("y="+y);

                      

             B:看程序写结果:

                       intx = 2;

                       inty = 3;

                       switch(x){

                                default:

                                         y++;

                                case3:

                                         y++;

                                case4:

                                         y++;

                       }

                       System.out.println("y="+y);

    1.5Java语言基础(选择结构if语句和switch语句的区别)

             A:案例演示

                       分别用switch语句和if语句实现下列需求:

                                键盘录入月份,输出对应的季节

             B:在做判断的时候,我们有两种选择,if语句和switch语句,那么,我们到底该如何选择使用那种语句呢?

                       if语句使用场景:

                                针对结果是boolean类型的判断

                                针对一个范围的判断

                                针对几个常量值的判断

                       switch语句使用场景:

                                针对几个常量值的判断                  

    1.6Java语言基础(for语句的格式及其使用)(掌握)

       案例:在控制台输出10次"helloworld";

             A:什么是循环结构

             循环语句可以在满足循环条件的情况下,反复执行某一段代码,这段被重复执行的代码被称为循环体语句,当反复执行这个循环体时,需要在合适的时候把循环判断条件修改为false,从而结束循环,否则循环将一直执行下去,形成死循环

             B:循环结构的分类

                       for循环

                       while循环

    do….while循环

             C循环结构for语句的格式:

                       for(初始化表达式语句;判断条件语句;控制条件语句) {

                                循环体语句;

                       }

             D:执行流程:

                       a:执行初始化表达式语句

                       b:执行判断条件语句,看其返回值是true还是false

                                如果是true,就继续执行

                                如果是false,就结束循环

                       c:执行循环体语句;

                       d:执行控制条件语句

                       e:回到B继续。     

        注意:初始化表达式只执行一次

                               

    把刚才的需求使用for循环进行改进。   

    1.7Java语言基础(循环结构for语句的练习之获取数据)

             B:注意事项

           a: 初始化表达式语句只执行一次

                       b:判断条件语句无论简单还是复杂结果是boolean类型。

                       c:循环体语句如果是一条语句,大括号可以省略;如果是多条语句,大括号不能省略。建议永远不要省略。

                       d:一般来说:有左大括号就没有分号,有分号就没有左大括号

    1.12Java语言基础(循环结构while语句的格式和基本使用)(掌握)

             A:循环结构while语句的格式:

                       while循环的基本格式:

                                while(判断条件语句) {

                                         循环体语句;

                                }

                       完整格式:

                           初始化条件语句;

                           while(判断条件语句) {

                                          循环体语句;

                                          控制条件语句;

                                }

             B:执行流程:

                       a:执行初始化条件语句;

                       b:执行判断条件语句,看其返回值是true还是false

                                如果是true,就继续执行

                                如果是false,就结束循环

                       c:执行循环体语句;

                       d:执行控制条件语句

                       e:回到b继续。

            

    1.14Java语言基础(循环结构do...while语句的格式和基本使用)(了解)

             A:循环结构do...while语句的格式:

                       do{

                                循环体语句;

                       }while(判断条件语句);

                      

                       完整格式;

                                初始化条件语句;

                                do{

                                         循环体语句;

                                         控制条件语句;

                                }while(判断条件语句);

             B:执行流程:

                       a:执行初始化条件语句;

                       b:执行循环体语句;

                       c:执行控制条件语句;

                       d:执行判断条件语句,看其返回值是true还是false

                                如果是true,就继续执行

                                如果是false,就结束循环

                       e:回到b继续。

            

    1.17Java语言基础(循环结构三种循环语句的区别)(掌握)

             三种循环语句的区别:

                       (1):do...while循环至少执行一次循环体。

                                而for,while循环必须先判断条件是否成立,然后决定是否执行循环体语句。

                       (2):A:如果你想在循环结束后,继续使用控制条件的那个变量,用while循环,否则用for循环。不知道用for循环。

                                         因为变量及早的从内存中消失,可以提高内存的使用效率。

                                B:知道循环次数用for,不知道用while  举例水仙花,吃葡萄,不能够数葡萄有多少个

    1.18Java语言基础(循环结构注意事项之死循环)(掌握)
    A:一定要注意控制条件语句控制的那个变量的问题,不要弄丢了,否则就容易死循环。
             B:两种最简单的死循环格式
                       while(true){...}
                       for(;;){...}
    1.20Java语言基础(循环结构循环嵌套输出4行5列的星星)

    嵌套循环格式:

      for(初始化条件语句;判断条件语句;控制条件语句){

                for(初始化条件语句;判断条件语句;控制条件语句){

                  循环体语句;

                  }

              }

    外循环

              内循环

              内面的内循环是外面的循环的循环体

                                System.out.println("*");和System.out.print("*");的区别

             B:结论:

                       外循环控制行数,内循环控制列数。

             B:代码优化

                       注意:

                       '\x' x表示任意,这种做法叫转义字符。

                      

                       '\t'    tab键的位置

                       '\n'   换行        

    1.23Java语言基础(控制跳转语句break语句)(掌握)

    A:什么是控制跳转语句

                       前面我们已经说过了,Java中的goto是保留字,目前不能使用。虽然没有goto语句可以增强程序的安全性,但是也带来很多不便,

                       比如说,我想在某个循环执行到某一步的时候就结束,现在就做不了这件事情。

                       为了弥补这个缺陷,Java就提供了break,continue和return来实现控制语句的跳转和中断。

             B:控制跳转语句的分类

                       break中断

                       continue继续

                       return返回

             C:break的使用场景

                       (1):在选择结构switch语句中

                       (2):在循环语句中

                       注意:离开使用场景的存在是没有意义的

             D:作用

                       a:退出单层循环

                       b:退出多层循环(几乎不使用)

                                要想实现这个效果,就必须知道一个东西;带标签的语句;

                                格式:标签名:语句

    1.24Java语言基础(控制跳转语句continue语句)

    A:continue的使用场景

                       (1):在循环语句中

                       (2):离开使用场景的存在是没有意义的

             B:作用

                       a:跳出一次循环,执行下一步操作

             C:练习题

                       for(intx=1; x<=10; x++) {

                                if(x%3==0){

                                         //在此处填写代码

                                }

                                System.out.println(“我要取代大黑牛”);

                       }

                      

    1.25Java语言基础(控制跳转语句return语句)

    A:return的作用

                       return就是退出一个方法。

                       跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。

             B:案例演示

                       return:            结束当前方法

                       break:                结束单层循环

                       continue:   结束当前循环,执行下一次循环

    1.26Java语言基础(方法概述和格式说明)

     

             A:为什么要有方法

                       假设有一个游戏程序,程序在运行过程中,要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码,在每次实现发射炮弹的地方都需要重复地编写这100行代码,这样程序会变得很臃肿,可读性也非常差。为了解决代码重复编写的问题,可以将发射炮弹的代码提取出来放在一个{}中,并为这段代码起个名字,这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中,所提取出来的代码可以被看作是程序中定义的一个方法,程序在需要发射炮弹时调用该方法即可。

             B:什么是方法

                       方法就是完成特定功能的代码块

                       在很多语言中都有函数的定义,但是在咱们JAVA语言中,我们将其称之为方法。

             C:方法的格式

                       修饰符返回值类型 方法名(参数类型参数名1,参数类型 参数名2 ....){

                                方法体;

                                return返回值;

                       }

             D:方法的格式详细说明

                       (1):修饰符                       比较多,后面会详细介绍。目前使用  public static

                       (2):返回值类型             用于限定返回值的数据类型(就是功能计算后结果的数据类型)

                       (3):方法名                        就是一个名称,它的存在是为了方便我们调用方法

                       (4):参数类型                  限定调用方法时传入参数的数据类型

                                        方法在运算时有没有未知数,未知数就定义为参数          

                       (5):参数名                       是一个变量,接收调用方法时传入的参数

                                                                               这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.

                       (6):方法体                       完成功能的代码

                       (7):return                          结束方法以及返回方法指定类型的值

                       (8):返回值                       就是功能的结果,由return带回,带回给调用者

     

    1.27Java语言基础(方法求和案例及其调用)

     

             A:需求:求两个数据之和的案例

             B:如何写一个方法

                       两个明确

                                (1):返回值类型      明确功能结果的数据类型

                                (2):参数列表           你要传递几个参数,以及每一个参数的数据类型

    如何调用?

                                直接写方法名,传递相应的参数即可.

             C:方法调用(有明确返回值的调用)

                       a:单独调用,一般来说没有意义,所以不推荐。

                       b:赋值调用,推荐方案。

                       c:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。        

     

    1.30Java语言基础(方法注意事项)

             A:     方法不调用不执行

             B:     方法与方法是平级关系,不能嵌套定义

             C:     方法定义的时候参数之间用逗号隔开

             D:     方法调用的时候不用在传递数据类型

             E:      如果方法有明确的返回值,一定要由return带回一个值

     

     ------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流! ----------

     

     

            

     

     

     

    展开全文
  • ------- android培训、java培训、期待与您交流!---------- 集合出现的意义: 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。 ...

    ------- android培训java培训、期待与您交流!----------

    集合出现的意义:
    面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。

    集合与数组的异同:

    容器长度:

    集合长度可变

    数组长度固定

    存储内容类型:

    集合存储引用数据类型

    数组存储任意类型

    是否可存储不同类型数据:

    集合可以存储不同类型数据

    数组只能存储相同数据类型

    集合概述
    Java中的集合: 

    JDK为我们提供了一套完整的容器类库,这些容器可以用于存储各种类型的对象,并且长度都是可变的,我们把这些类统称为集合类,它们都位于java.util包中。

    分类:

    单列集合Collection

    List:元素有序、包含重复元素

    Set:元素无序、不包含重复元素

    双列集合Map:

    键值映射关系

    其他功能接口:

    迭代器Iterator

    Comparable与Comparator用于比较元素

    集合——Collection:单列集合的根接口

    Collection

    List

    ArrayList:

    底层数据结构是数组,查询快,增删慢;

    线程不安全,效率高

    Vector:

    底层数据结构是数组,查询快,增删慢;

    线程安全,效率低

    LinkedList:

    底层数据结构是链表,查询慢,增删快;

    线程不安全,效率高

    Set

    HashSet:

    底层数据结构是哈希表

    如何保证其唯一性:

    依赖hashCode()和equals()

    先判断hashCode()值是否相同;如果相同就看equals(),看返回值。如果是true,就是元素重复,不添加;如果是false,就是元素不重复,添加。

    TreeSet:

    底层数据结构是二叉树;

    如何保证其唯一性:

    根据返回值是否是0;

    如何排序:

    自然排序:Comparable

    比较器排序:Comparator

    LinkedHashSet:

    底层数据结构是链表和哈希表;

    由链表保证有序(存储和去除一致);

    由哈希表保证元素唯一。

    主要方法:

    boolean add(E e)  添加元素   返回值类型表示:添加是否成功

    代码实现:

    package cn.itcast2;
    
    import java.util.ArrayList;
    import java.util.Collection;
    public class Demo2 {
    
    	public static void main(String[] args) {
    
    		//创建集合对象
    		Collection c = new ArrayList();
    		
    		//准备元素
    		int luckyNumber = 13;
    		String myWords = "休息时候十个小时都用到!";
    		Student s = new Student("刘亦菲",27);
    		
    		//将元素放到集合中
    		c.add(luckyNumber);
    		c.add(myWords);
    		c.add(s);
    		
    		//遍历集合
    		System.out.println(c);	
    	}
    }

    boolean remove(Object o)  删除指定元素

    该方法在删除元素时,会调用实参的equals方法,与老元素比较,如果相同则删除,否则不删除。

    代码实现:

    package cn.itcast2;
    
    import java.util.ArrayList;
    import java.util.Collection;
    public class Demo3 {
    
    	public static void main(String[] args) {
    
    		//创建集合对象
    		Collection c = new ArrayList();
    		//准备元素
    		int luckyNumber = 13;
    		String myWords = "休息时候十个小时都用到!";
    		Student s = new Student("刘亦菲",27);
    		//将元素放到集合中
    		c.add(luckyNumber);
    		c.add(myWords);
    		c.add(s);
    		//遍历集合
    		System.out.println(c);
    //		c.remove(s);
    		c.remove(new Student("刘亦菲",27));
    		System.out.println(c);
    	}


    void clear()  清空

    boolean contains(Object o) 如果此 collection 包含指定的元素

    boolean isEmpty()  判断是否为空

    int size() 判断容器内已经存在的元素个数

    代码实现:

    package cn.itcast2;
    
    import java.util.ArrayList;
    import java.util.Collection;
    public class Demo4 {
    
    	public static void main(String[] args) {
    
    		//创建集合对象
    		Collection c = new ArrayList();
    		//准备元素对象
    		Integer number = new Integer(13);
    		Integer number2 = new Integer(2);
    		Integer number3 = new Integer(250);
    		
    		//将元素添加到集合
    		c.add(number);
    		c.add(number2);
    		c.add(number3);
    		
    		//遍历集合
    		System.out.println(c);
    		
    		boolean contains = c.contains(250);
    		System.out.println(contains);
    		System.out.println(c.isEmpty());
    		System.out.println(c.size());
    		System.out.println("====================================");
    		c.clear();
    		System.out.println(c.size());
    		System.out.println(c.isEmpty());
    		System.out.println(c);
    	}
    
    }

    boolean retainAll(Collection c)   仅保留此 collection 中那些也包含在指定 collection 的元素,即求交集

    代码实现:

    package cn.itcast2;
    
    import java.util.ArrayList;
    import java.util.Collection;
    public class Demo6 {
    
    	public static void main(String[] args) {
    
    		Collection c = new ArrayList();
    		Collection c2 = new ArrayList();
    		
    		c.add("baby");
    		c.add("宝强");
    		c.add("祖蓝");
    		c.add("邓超");
    		c.add("大黑牛");
    		
    		c2.add("宝强");
    		c2.add("祖蓝");
    		c2.add("大黑牛");
    //		c2.add("何炅");
    		
    		System.out.println(c);
    		System.out.println(c2);
    		
    		System.out.println(c.retainAll(c2));
    		System.out.println(c);
    		
    		Collection c3 = new ArrayList();
    		
    		System.out.println(c.retainAll(c3));
    		System.out.println(c);
    	}
    
    }

    单列集合迭代器方法:

    Iterator iterator() 返回在此 collection 的元素上进行迭代的迭代器。

    迭代器:用来迭代的工具,用来遍历集合的工具。

    迭代器的方法:

    boolean hasNext()  如果仍有元素可以迭代,则返回 true。

    集合中存储的数据类型  next()  返回迭代的下一个元素。 默认是Object。

    代码实现:

    package cn.itcast2;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    public class Demo7 {
    		
    	public static void main(String[] args) {
    
    		//创建集合对象
    		Collection c = new ArrayList();
    		//准备元素对象
    		String name = "卢俊义";
    		String name2 = "宋江";
    		String name3 = "扈三娘";
    		String name4 = "孙二娘";
    		String name5 = "顾大嫂";
    		//将元素放入到集合
    		c.add(name);
    		c.add(name2);
    		c.add(name3);
    		c.add(name4);
    		c.add(name5);
    		//迭代集合(遍历集合)
    		//a:产生该集合的迭代器
    		Iterator i = c.iterator();
    		//b:调用迭代器的方法,遍历集合
    		while(i.hasNext()) {
    			Object next = i.next();
    			String sNext = (String)next;
    			System.out.println(sNext);
    		}
    		
    		System.out.println("获取完了!");	
    

    	}

    }

    List接口:单列集合,可存放重复元素,元素有序。

    ArrayList:底层数据结构是数组结构。线程不安全的。所以ArrayList的出现替代了Vector。增删慢,改查快。

    LinkedList:底层是链表数据结构。线程不安全的,同时对元素的增删操作效率很高。

    Vector:底层数据结构是数组结构。jdk1.0版本。线程安全的。无论增删还是查询都非常慢.已被ArrayList替代。

    特殊方法:

    void add(int index,E element)  在指定索引处添加指定元素

    E remove(int index)  删除指定元素,并将这个被删除的元素返回

    E get(int index)  根据元素索引获取指定元素对象

    E set(int index, E element)用指定元素替换列表中指定位置的元素   将被替换掉的元素对象返回

    代码实现:

    package cn.itcast3;
    
    import java.util.ArrayList;
    import java.util.List;
    public class Demo {
    
    	public static void main(String[] args) {
    		
    		List list = new ArrayList();
    		
    		list.add("史进");
    		list.add("燕顺");
    		list.add("杨林");
    		list.add("杨志");
    		System.out.println(list);
    		
    		list.add(2, "花荣");
    		System.out.println(list);
    		
    		String remove = (String)(list.remove(3));
    		System.out.println(remove);
    		System.out.println(list);
    		
    		System.out.println("=========================");
    		
    		System.out.println(list.get(2));
    		System.out.println(list.set(2,"李广"));
    		System.out.println(list);
    	}
    
    }

    int indexOf(Object o)  通过内容返回索引。返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1

    int lastIndexOf(Object o)  返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。

    代码实现:

    package cn.itcast3;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import cn.itcast2.Person;
    
    public class Demo2 {
    
    	public static void main(String[] args) {
    
    		List list = new ArrayList();
    		
    		list.add(120);
    		list.add(10);
    		list.add(10);
    		list.add(10);
    		
    		System.out.println(list.indexOf(10));
    		System.out.println(list.lastIndexOf(10));
    		
    		List list2 = new ArrayList();
    		
    		Person p = new Person("花荣",18);
    		list2.add(p);
    		list2.add(new Person("孙悟空",503));
    		list2.add(new Person("牛魔王",600));
    		list2.add(new Person("朱茵",42));
    		
    		System.out.println(list2.indexOf(new Person("花荣", 18)));
    		System.out.println(list2.indexOf(p));
    	}
    
    }

    LinkedList: List的链表实现,提供了许多头尾操作

    public void addFirst(E e) 在集合头部添加元素

    public void addLast(E e)  在集合尾部添加元素

    public E getFirst() 获取头部元素

    public E getLast()  获取尾部元素


    增强for循环(foreach循环):

    用于快速遍历集合或数组的方式

    格式:

    for (容器内类型   临时变量 : 被遍历的容器){

    使用临时的变量

    }

    代码实现:

    package cn.itcast;
    
    import java.util.LinkedList;
    package cn.itcast;
    
    import java.util.LinkedList;
    public class Demo3 {
    
    	public static void main(String[] args) {
    
    		LinkedList ll = new LinkedList();
    		
    		ll.add("石秀");
    		ll.add("时迁");
    		ll.add("石头");
    		
    		System.out.println(ll);
    		
    		ll.addFirst("石破天");
    		ll.addLast("史进");
    		
    		for (Object s: ll) {
    			String s2 = (String)s;
    			System.out.println(s2);
    		}
    		System.out.println("==========================");
    		System.out.println(ll.getFirst());
    		System.out.println(ll.getLast());
    	}
    
    }

    Set接口:单列集合,无序,元素不得重复。

    Set方法取出元素只能使用迭代器。

    Set主要子类:

    HashSet:线程不安全,存取速度快

    底层结构为哈希表结构,即区分元素时使用hash值。可以通过hashCode与equals方法的重写,保证元素唯一性。具体代码体现为:先判断哈希值是否相等,再判断equals方法是否返回true。true则为相同元素,存储元素失败,false则为不同元素,存储元素成功。

    TreeSet: 线程不安全,可以对集合中的元素进行排序。

    通过Comparable让集合内元素具备比较性。

    通过Comparator让集合具备比较某种类型元素的能力。

    当Comparator与Comparable冲突时,以Comparator作为标准。

    LinkedHashSet:在HashSet集合的基础上,使迭代顺序可预测

    HashSet代码实现:

    package cn.itcast2;
    
    import java.util.HashSet;
    import java.util.Set;
    public class Demo {
    
    	public static void main(String[] args) {
    
    		Set set = new HashSet();
    		
    		String name = "梅超风";
    		String name2 = "杨过";
    		String name3 = "小龙女";
    		String name4 = "公孙策";
    		String name5 = "包拯";
    		String name6 = "元芳";
    		String name7 = "元芳";
    		
    		set.add(name);
    		set.add(name2);
    		set.add(name3);
    		set.add(name4);
    		set.add(name5);
    		set.add(name6);
    		set.add(name7);
    		
    		System.out.println(set);
    		
    		Set set2 = new HashSet();
    		
    		set2.add(new Light("白炽灯",40));
    		set2.add(new Light("疝气灯",200));
    		set2.add(new Light("霓虹灯",20));
    		set2.add(new Light("霓虹灯",20));
    		
    		System.out.println(set2);
    	}
    
    }

    TreeSet代码实现:

    package cn.itcast2;
    
    import java.util.TreeSet;
    
    public class Demo4 {
    
    	public static void main(String[] args) {
    
    		TreeSet ts = new TreeSet();
    		
    		String name = "b黄月英";
    		String name2 = "a小乔";
    		String name3 = "d貂蝉";
    		String name4 = "c大乔";
    		String name5 = "c大乔";
    		
    		ts.add(name);
    		ts.add(name2);
    		ts.add(name3);
    		ts.add(name4);
    		ts.add(name5);
    		
    		for(Object obj : ts) {
    			String s= (String)obj;
    			System.out.println(s);
    		}
    		
    		TreeSet ts2 = new TreeSet();
    		
    		Integer i = new Integer("10");
    		Integer i2 = new Integer("100");
    		Integer i3 = new Integer("120");
    		Integer i4 = new Integer("130");
    		
    		ts2.add(i2);
    		ts2.add(i4);
    		ts2.add(i);
    		ts2.add(i3);
    		
    		System.out.println(ts2);
    	}
    
    }

    LinkedHashSet代码实现:



    package cn.itcast2;
    
    import java.util.Iterator;
    import java.util.LinkedHashSet;
    
    public class Demo3 {
    
    	public static void main(String[] args) {
    
    		LinkedHashSet lhs = new LinkedHashSet();
    		
    		lhs.add("b许攸");
    		lhs.add("a曹操");
    		lhs.add("d贾诩");
    		lhs.add("c周瑜");
    		lhs.add("c周瑜");
    		
    		Iterator iterator = lhs.iterator();
    		
    		while(iterator.hasNext()) {
    			Object next = iterator.next();
    			String s = (String)next;
    			System.out.println(s);
    		}
    	}
    
    }

    泛型

    用泛型的好处:

    用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数传递。

    泛型的优点:

    提高程序的安全性

    将运行期问题转移到了编译期

    省去了类型强转的麻烦

    优化了程序设计

    泛型的使用:

    将运行时异常提前到编译期

    提高了安全性

    省去了类型强制转换的麻烦

    代码实现:

    package cn.itcast2;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class Demo {
    
    	public static void main(String[] args) {
    
    		ArrayList<String> list = new ArrayList<String>();
    		
    		list.add("唐嫣");
    		list.add("柳岩");
    		list.add("baby");
    		list.add("祖蓝");
    //		list.add(100);
    		
    		Iterator<String> iterator = list.iterator();
    		
    		while (iterator.hasNext()) {
    			String string = iterator.next();
    			System.out.println(string);
    		}
    		
    		for (String string : list) {
    			System.out.println(string);
    		}
    	}
    
    }
    泛型类:在类上定义泛型,类中使用该类型

    格式:class 类名<T>{使用T}

    代码实现:

    package cn.itcast2;
    
    public class Demo4 {
    
    	public static void main(String[] args) {
    
    		Demo3<String> demo3 = new Demo3<String>();
    		
    		demo3.setT("我是一个字符串");
    		String t = demo3.getT();
    		
    		System.out.println(t);
    		
    		
    		Demo3<Integer> demo32 = new Demo3<Integer>();
    		demo32.setT(123);
    		Integer t2 = demo32.getT();
    		System.out.println(t2);
    		
    		//Demo3<int> demo33 = new Demo3<>();
    		
    //		Demo3<String, Integer> demo3 = new Demo3<String, Integer>();
    //		
    //		demo3.setT("String");
    //		String t = demo3.getT();
    //		
    //		demo3.method(100);
    	}
    
    }

    泛型方法:在方法上定义泛型,方法内使用泛型,与类无关。

    格式:public <T> void method(){使用T}

    代码实现:

    package cn.itcast2;
    
    public class Demo6<T> {
    
    	public static void main(String[] args) {
    
    		Demo6<String> demo6 = new Demo6<String>();
    		demo6.method("我是泛型类中指定的类型");
    		Integer i = 100;
    		demo6.method2(i);
    	}
    
    	public void method(T t) {
    		System.out.println(t);
    	}
    	
    	public <E> void method2(E e) {
    		
    		E e2 = e;
    		System.out.println(e2);
    	}
    }

    泛型接口:在接口上使用泛型。

    格式:interface 接口名<T>{}

    在类实现接口时明确泛型类型

    在类实现接口时仍不明确泛型类型,在创建对象时明确泛型类型

    代码实现:

    package cn.itcast2;
    
    public class MyClass implements MyInterface<String> {
    
    	@Override
    	public void method(String t) {
    
    		System.out.println(t);
    	}
    }
    package cn.itcast2;
    
    public class MyClass2<T> implements MyInterface<T> {
    
    	@Override
    	public void method(T t) {
    		System.out.println(t);
    	}
    	
    }
    package cn.itcast2;
    
    public class Demo7 {
    
    	public static void main(String[] args) {
    		
    		MyClass mc = new MyClass();
    		mc.method("我是在定义类的时候,已经给接口的泛型指定了数据类型");
    		System.out.println("这种在定义类时已经指定了泛型的类,在创建对象时,无需再指定类型");
    		
    		MyClass2<Integer>  mc2 = new MyClass2<Integer>();
    		mc2.method(100);
    		System.out.println("这种在定义类时没有指定泛型的类,在创建对象时,需再指定类型");
    		
    	}
    }

    Map——双列集合

    定义:

    Map为双列集合,存储的每个元素均为键值对,对键进行约束。可以通过键找到该建对应的值。

    Map集合无法返回对应的迭代器。其内容需要调用方法进行访问。

    主要格式:

    Map<k,v>

    key - 此映射所维护的键的类型

    value - 映射值的类型

    主要子类:

    HashMap:底层为哈希表结构的Map集合。

    Hashtable:底层为哈希表结构的Map集合。

    TreeMap:对键进行排序,排序原理与TreeSet相同的Map集合。

    LinkedHashMap:可预知顺序的HashMap集合

    Map集合功能:

    添加功能:

    public V put(K key, V value)

    删除功能:

    public V remove(Object key)

    获取功能:

    public V get(Object key)

    public Set<K> keySet()

    public Collection<V> values()

    判断功能:

    public boolean containsKey(Object key)

    public boolean containsValue(Object value)

    获取长度:

    public int size()

    Map集合的遍历

    方式一:

    创建集合对象

    创建元素对象

    将元素放到集合中

    返回这个Map中的所有键的Set集合

    迭代键的Set集合,依次获取每一个键

    根据Map中的每一个键获取Map中的每一个值

    代码实现:

    package cn.itcast2;
    
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class Demo6 {
    
    	public static void main(String[] args) {
    
    		method();
    		System.out.println("=================");
    		method2();
    		System.out.println("=================");
    		method3();
    	}
    	
    	//遍历所有的键与值
    	public static void method3() {
    		
    		//创建集合对象
    		Map<String, String> map = new HashMap<>();
    		//创建元素对象
    		//将元素放到集合中
    		map.put("操刀鬼", "曹正");
    		map.put("旱地忽律", "朱贵");
    		map.put("鬼脸", "杜兴");
    		map.put("母夜叉", "孙二娘");
    		
    		//返回所有的键的集合
    		Set<String> keySet = map.keySet();
    		
    		Iterator<String> iterator = keySet.iterator();
    		while(iterator.hasNext()) {
    			//依次获取到每一个键
    			String key = iterator.next();
    			
    			//根据map中的每一个键获取map中的每一个值
    			String value = map.get(key);
    			System.out.println(key+":"+value);
    		}
    		
    	}
    	
    	//遍历所有值
    	public static void method2() {
    		Map<String, String> map = new HashMap<>();
    		
    		map.put("操刀鬼", "曹正");
    		map.put("旱地忽律", "朱贵");
    		map.put("鬼脸", "杜兴");
    		map.put("母夜叉", "孙二娘");
    		//遍历所有的值
    		Collection<String> values = map.values();
    		
    //		Iterator<String> iterator = values.iterator();
    //		while (iterator.hasNext()) {
    //			String string = (String) iterator.next();
    //			System.out.println(string);
    //		}
    		
    		for (String string : values) {
    			System.out.println(string);
    		}
    		
    	}
    	//遍历所有键
    	public static void method() {
    		Map<String, String> map = new HashMap<>();
    		
    		map.put("操刀鬼", "曹正");
    		map.put("旱地忽律", "朱贵");
    		map.put("鬼脸", "杜兴");
    		map.put("母夜叉", "孙二娘");
    		
    		//遍历所有的键
    		Set<String> keySet = map.keySet();
    		
    //		Iterator<String> iterator = keySet.iterator();
    //		while(iterator.hasNext()) {
    //			System.out.println(iterator.next());
    //		}
    		
    		for (String string : keySet) {
    			System.out.println(string);
    		}
    	}
    
    }

    方式二:

    public Set<Map.Entry<K,V>> entrySet() 返回此映射所包含的映射关系的 Set 视图。

    Entry:

    映射项,即键值对对应关系

    K getKey()  获取键

    V getValue()  获取值

    代码实现:
    package cn.itcast2;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    
    public class Demo7 {
    
    	public static void main(String[] args) {
    
    		Map<String, String> map = new HashMap<String, String>();
    		
    		map.put("胡一菲", "曾小贤");
    		map.put("张子萱", "曾小贤");
    		map.put("静静", "曾小贤");
    		
    		//调用entrySet方法,返回键值对对应关系的Set集合
    		Set<Entry<String,String>> entrySet = map.entrySet();
    		
    		//迭代键值对对应关系集合
    		Iterator<Entry<String, String>> iterator = entrySet.iterator();
    		
    		//迭代拿到每一个对应关系
    		while(iterator.hasNext()) {
    			Entry<String, String> thisEntry = iterator.next();
    			
    			//通过键值对对应关系获取键
    			String key = thisEntry.getKey();
    			//通过键值对对应关系获取值
    			String value = thisEntry.getValue();
    			System.out.println(key+":"+value);
    		}
    	}
    
    }

    Map签到Map的代码实现:

    package cn.itcast2;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class Test2 {
    
    	public static void main(String[] args) {
    
    		//创建集合对象  Map学校   第一个泛型是:学校名称(String)    第二个泛型:学校的班级(Map)    
    		//班级Map:第一个泛型:班级名称(String)   第二个泛型:班级个数(Integer)
    		
    		//创建学校集合
    		Map<String, Map<String,Integer>> school = new HashMap<String, Map<String,Integer>>();
    		
    		//为北京准备班级(为school这个集合准备元素对象)
    		String name = "北京总部";
    		Map<String, Integer> class1 = new HashMap<String, Integer>();
    			//为第一个班添加内容
    		class1.put("javaSE", 5);
    		class1.put("javaEE", 4);
    		class1.put("Android", 4);
    		class1.put("iOS", 4);
    		
    		//为上海准备班级(为school这个集合准备另外的元素对象)
    		String name2 = "上海分校";
    		Map<String, Integer> class2 = new HashMap<String, Integer>();
    			//为第一个班添加内容
    		class2.put("javaSE", 2);
    		class2.put("javaEE", 3);
    		class2.put("Android", 2);
    		class2.put("iOS", 10);
    		
    		school.put(name, class1);
    		school.put(name2, class2);
    		
    		System.out.println(school);
    		
    		//遍历
    		//获取学校的所有元素对象
    		//返回所有学校名称的set集合      (key的set集合)
    		Set<String> keySet = school.keySet();
    		
    		Iterator<String> iterator = keySet.iterator();
    		
    		while (iterator.hasNext()) {
    			//依次拿到每一个学校的key
    			String outKey = (String) iterator.next();
    			System.out.println(outKey);
    			//根据学校的key找到学校对应的值
    			Map<String, Integer> outMap = school.get(outKey);
    			
    			//获取每一个学校的key的Set集合
    			Set<String> innerKeySet = outMap.keySet();
    			
    			Iterator<String> iterator2 = innerKeySet.iterator();
    			
    			while (iterator2.hasNext()) {
    				//依次找到每一个内部Map的key
    				String innerKey = iterator2.next();
    				//再根据每一个内部Map的Key找到内部Map的value
    				Integer innerValue = outMap.get(innerKey);
    				//打印集合内容
    				System.out.println("\t"+innerKey+":"+innerValue);
    			}
    		}
    	}
    
    }


    展开全文
  • 个人项目

    2019-09-24 04:31:34
    本次作业所属课程 2019北航软件工程暑期师资培训 本次作业要求 实现一个帮助进行地铁出行路线规划的命令行程序。 本次作业目标 使用IDEA开发工具,实现一个帮助进行地铁出行路线规划的命令行程序;并了解GitHub管理...

    本次作业所属课程 2019北航软件工程暑期师资培训

    本次作业要求 实现一个帮助进行地铁出行路线规划的命令行程序。
    本次作业目标 使用IDEA开发工具,实现一个帮助进行地铁出行路线规划的命令行程序;并了解GitHub管理源代码流程
    本次作业的帮助 在老师帮助下使用GitHub
    本项目实现一个帮助进行地铁出行路线规划的命令行程序,参照平时实际出行时情况,考虑换乘、候车的时间等代价,在求地铁线路最短路径时,也按换乘次数最少来实施的。因能力有限,程序若有不完善的地方,尽情老师谅解。

    1. 地铁线路信息等用一个名为subway.txt文本文件存储,文件内容及格式如下:

    1号线:刘园,西横堤,果酒厂,本溪路,勤俭道,洪湖里,西站#6,西北角,西南角#2,二纬路,海光寺,鞍山道,营口道#3,小白楼,下瓦房#5,南楼,土城,陈塘庄,复兴门,华山里,财经大学,双林,李楼
    2号线:曹庄,卞兴,芥园西道,咸阳路,长虹公园#6,广开四马路,西南角#1,鼓楼,东南角,建国道,天津站#3#9,远洋国际中心,顺驰桥,靖江路#5,翠阜新村,屿东城,登州路,国山路,空港经济区,滨海国际机场
    3号线:小淀,丰产河,华北集团,天士力,宜兴埠,张兴庄#5,铁东路,北站#6,中山路,金狮桥,天津站#2#9,津湾广场,和平路,营口道#1,西康路,吴家窑,天塔,周邓纪念馆,红旗南路#6,王顶堤,华苑,大学城,高新区,学府工业区,杨伍庄,南站
    5号线:北辰科技园北,丹河北道,北辰道,职业大学,淮河道,辽河北道,宜兴埠北,张兴庄#3,志成路,思源道,建昌道,金钟河大桥#6,月牙河,幸福公园,靖江路#2,成林道,津塘路,直沽#9,下瓦房#1,西南楼,文化中心#6,天津宾馆#6,肿瘤医院#6,体育中心,凌宾路,昌凌路,中医一附院,李七庄南
    6号线:南孙庄,南何庄,大毕庄,金钟街,徐庄子,金钟河大桥#5,民权门,北宁公园,北站#3,新开河,外院附中,天泰路,北运河,北竹林,西站#1,复兴路,人民医院,长虹公园#2,宜宾道,鞍山西道,天拖,一中心医院,红旗南路#3,迎风道,南翠屏,水上公园东路,肿瘤医院#5,天津宾馆#5,文化中心#5,乐园道,尖山路,黑牛城道,梅江道,左江道,梅江公园,梅江会展中心,解放南路,洞庭路,梅林路
    9号线:天津站#2#3,大王庄,十一经路,直沽#5,东兴路,中山门,一号桥,二号桥,张贵庄,新立,东丽开发区,小东庄,军粮城,钢管公司,胡家园,塘沽,泰达,市民广场,太湖路,会展中心,东海路

    线路名称后用“:”与其后站点间隔,站点与站点间用“,”间隔;
    若某站为换乘或中专站点,在其后用“#数字”,表示在此线路的这个站点上可以换乘到数字序号所指的线路上,如1号线的西站可以转到6号线,9号线的天津站可以转到2号线和3号线。
    2.问题涉及到信息较简单,没有画用例图,直接在Java语言中定义了相关的类,具体有:
    站点Station类:
    name; // 站点名称
    routerIdList; // 包括该站点所有线路的列表
    线路Router类:
    name; //路线名称
    stations; //路线上所有站点
    路径Path类
    count; //路径上站点数
    pathName; //路径上所有站点名称组成的字符串,空格间隔
    主类中具体实现任务,具体思路:
    (1) 因为是一个帮助进行地铁出行路线规划的命令行程序,会涉及到命令中的参数,需要用main方法中的args参数去实现。
    (2) 功能一:获取地铁线路图的信息,执行java subway –map subway.txt 。
    先将subway.txt文件中的信息生成所有的线路信息routers和站点信息stations,实现了与地铁信息文件subway.txt的解耦,然后按要求输出routers中所有数据。
    功能二:获取指定线路自起始站点到终点站点的所有站点信息并存储到station.txt文件中,执行java subway -a 1号线 -map subway.txt -o station.txt(1号线只是举例,可换其他线路)。
    同功能一类似,只是需具体到线路routers中取指定线路信息,按每个站点一行的格式输出到station.txt文件。
    功能三:获取起始站点和目的站点间的最短路径,执行Java subway -b 洪湖里 复兴路 -map subway.txt -o routine.txt。(洪湖里、复兴路为起始站点和目的站点,可换地铁线路图上其他任何两个站点)
    此功能是本程序的重点和难点,基于换乘次数最少的原则,分下面几种情况处理:
     起始站点和目的站点在同一线路上:直接计算路径的站点数和依次包含的站点名称即可
     起始站点和目的站点不在同一线路上,但两个站点分别所在的两条线路有交汇点,即中转站点,此时问题转化为求:起始站点和中转站点的路径、中转站点和目的站点的路径。
     起始站点和目的站点不在同一线路上,且两个站点分别所在的两条线路没有交汇点(如1号线和9号线),此时处理方法是首先分别获取起两条线路上的所有中转站点集合,在这两个中转站点集合里各选出一个中转站点,假如是ss站点和se站点,则构成一条自起始站点--->ss站点--->se站点--->目的站点的路径,所有这样的路径中最短的那条路径即是所求路径。
    3.因无项目经验,所以项目开发流程不规范,实际程序编写过程可能不能完全对应项目开发流程,仅做一简单的用时总结,程序思路基本上用了5小时(因工作原因,先后在两天内完成),具体开始设计程序时,类的设计在功能性模块实现时有修改,具体时间不再估计;第一版程序代码完成后,进行自我测试、反复修改,这个用时较多,先后用了大概6天时间,每天4小时左右吧。
    4.测试用例,存储在具体“个人项目测试用例.txt”文件中。

    转载于:https://www.cnblogs.com/hymhdxy/p/11221957.html

    展开全文
1
收藏数 3
精华内容 1
热门标签