zoukankan      html  css  js  c++  java
  • 李晓菁201771010114《面向对象程序设计(Java)》第十一周学习总结

    集合

    一:.数据结构介绍

    1.一般将数据结构分为两大类:线性数据结构和非线性数据结构。

    (1)线性数据结构:线性表、栈、队列、串、数组和文件。

    (2)非线性数据结构:树和图。

    2.线性表:

    3.链表:(1)单向链表

    (2)循环链表

    (3)双向循环链表

    4.栈:栈(Stack)也是一种特殊的线性表,是一种后进先出(LIFO)的结构。栈是限定仅在表尾进行插入和删除运算的线性表,表尾称为栈顶(top),

    表头称为栈底(bottom)。

    5.队列:队列(Queue)是限定所有的插入只能在表的一端进行,而所有的删除都在表的另一端进行的线性表。

    表中允许插入的一端称为队尾(Rear),允许删除的一端称为队头(Front)。

    队列的操作是按先进先出(FIFO)的原则进行的。

    6.散列表:散列表又称为哈希表。散列表算法的基本思想是:以结点的关键字为自变量,通过一定的函数关系(散列函数)计算出对应的函数值,

    以这个值作为该结点存储在散列表中

    的地址。当散列表中的元素存放太满,就必须进行再散列,将产生一个新的散列表,所有元素存放到新的散列表中,原先的散列表将被删除。

    7.JAVA的集合框架:JAVA的集合框架实现对各种数据结构的封装,以降低对数据管理与处理的难度所谓框架就是一个类库的集合,

    框架中包含很多超类,编程者创建这些超类的子类可较方便的设计设计程序所需的类。例如:Swing类包

    集合(Collection或称为容器)是一种包含多个元素并提供对所包含元素操作方法的类,其包含的元素可以由同一类型的对象组成,也可以由不同类

    型的对象组成。

    8.集合类的作用:

    – Java的集合类提供了一些基本数据结构的支持。
    – 例如Vector、Hashtable、Stack等。

    9.集合类的使用:

    – Java的集合类包含在java.util包中。
    – import java.util.*;

    10.集合类的特点:

    (1)只容纳对象。数组可以容纳基本数据类型数据和对象。

    如果集合类中想使用基本数据类型,又想利用集合类的灵活性,可以把基本数据类型数据封装成该数据类型的包装器对象,然后放入集合中处理。

    (2) 集合类容纳的对象都是Object类的实例,一旦把一个对象置入集合类中,它的类信息将丢失,这样设计的目的是为了集合类的通用性。

    因为Object类是所有类的祖先,所以可以在这些集合中存放任何类的对象而不受限制,但切记在使用集合成员之前必须对它重新造型。

    11.新旧集合类:在JDK1.0和JDK 1.1中提供了Vector(矢量),Hashtable ( 哈希表) , Stack ( 堆栈) ,Properties(属性集)等集合类,

    尽管这些类非常有用,但却彼此独立,缺少一个统一集中的机制。

    (1)Vector类:Vector类类似长度可变的数组。 Vector中只能存放对象。 Vector的元素通过下标进行访问。

    (2)Stack类:Stack类是Vector的子类。 Stack类描述堆栈数据结构,即LIFO。

    (3)Hashtable类:Hashtable通过键来查找元素。Hashtable用散列码(hashcode)来确定键。

    所有对象都有一个散列码,可以通过Object类的hashCode()方法获得。

    12.在JDK1.2中,JAVA设计了一个统一的类集,并对上述类进行了改写,使其统一纳入JAVA的集合框架。

    集合框架中的基本接口:

    (1)Collection:集合层次中的根接口,JDK未提供这个接口的直接实现类。

    (2)Set:不能包含重复的元素。对象可能不是按存放的次序存放,也就是说不能像数组一样按索引的方式进行访问,SortedSet是一个按照升序排列元素的Set。

    (3)List:是一个有序的集合,可以包含重复的元素。提供了按索引访问的方式。

    (4)Map:包含了key-value对。Map不能包含重复的key

    (5)SortedMap是一个按照升序排列key的Map。

    实验十一   集合

    实验时间 2018-11-8

    1、实验目的与要求

    (1) 掌握Vetor、Stack、Hashtable三个类的用途及常用API;

    (2) 了解java集合框架体系组成;

    (3) 掌握ArrayList、LinkList两个类的用途及常用API。

    (4) 了解HashSet类、TreeSet类的用途及常用API。

    (5)了解HashMap、TreeMap两个类的用途及常用API;

    (6) 结对编程(Pair programming)练习,体验程序开发中的两人合作。

    2、实验内容和步骤

    实验1: 导入第9章示例程序,测试程序并进行代码注释。

    测试程序1:

    l 使用JDK命令运行编辑、运行以下三个示例程序,结合运行结果理解程序;

    l 掌握Vetor、Stack、Hashtable三个类的用途及常用API。 

    //示例程序1

    import java.util.Vector;

    class Cat {

    private int catNumber;

    Cat(int i) {

    catNumber = i;

    }

    void print() {

    System.out.println("Cat #" + catNumber);

    }

    }

    class Dog {

    private int dogNumber;

    Dog(int i) {

    dogNumber = i;

    }

    void print() {

    System.out.println("Dog #" + dogNumber);

    }

    }

    public class CatsAndDogs {

    public static void main(String[] args) {

    Vector cats = new Vector();

    for (int i = 0; i < 7; i++)

    cats.addElement(new Cat(i));

    cats.addElement(new Dog(7));

    for (int i = 0; i < cats.size(); i++)

    ((Cat) cats.elementAt(i)).print();

    }

    }

    //示例程序2

    import java.util.*;

    public class Stacks {

    static String[] months = { "1", "2", "3", "4" };

    public static void main(String[] args) {

    Stack stk = new Stack();

    for (int i = 0; i < months.length; i++)

    stk.push(months[i]);

    System.out.println(stk);

    System.out.println("element 2=" + stk.elementAt(2));

    while (!stk.empty())

    System.out.println(stk.pop());

    }

    }

    //示例程序3

    import java.util.*;

    class Counter {

    int i = 1;

    public String toString() {

    return Integer.toString(i);

    }

    }

    public class Statistics {

    public static void main(String[] args) {

    Hashtable ht = new Hashtable();

    for (int i = 0; i < 10000; i++) {

    Integer r = new Integer((int) (Math.random() * 20));

    if (ht.containsKey(r))

    ((Counter) ht.get(r)).i++;

    else

    ht.put(r, new Counter());

    }

    System.out.println(ht);

    }

    }

    示例程序1运行结果如下:

    import java.util.Vector;
    
    class Cat {
        private int catNumber;
    
        Cat(int i) {
            catNumber = i;
        }
    
        void print() {
            System.out.println("Cat #" + catNumber);
        }
    }
    
    class Dog {
        private int dogNumber;
    
        Dog(int i) {
            dogNumber = i;
        }
    
        void print() {
            System.out.println("Dog #" + dogNumber);
        }
    }
    
    public class CatsAndDogs {
        public static void main(String[] args) {
            Vector cats = new Vector();
            for (int i = 0; i < 7; i++)
                cats.addElement(new Cat(i));
            cats.addElement(new Dog(7));
            for (int i = 0; i < cats.size(); i++) {
                //if(cats.elementAt(i) instanceof Cat) {
                    //((Cat) cats.elementAt(i)).print();    
                //}
                ((Cat) cats.elementAt(i)).print();//程序有未检查异常
        
    //        else {
        //        ((Dog) cats.elementAt(i)).print();
        //    }
        }
    }
    }
    demo1

    程序进行修改后:

    import java.util.Vector;
    
    class Cat {
        private int catNumber;
    
        Cat(int i) {
            catNumber = i;
        }
    
        void print() {
            System.out.println("Cat #" + catNumber);
        }
    }
    
    class Dog {
        private int dogNumber;
    
        Dog(int i) {
            dogNumber = i;
        }
    
        void print() {
            System.out.println("Dog #" + dogNumber);
        }
    }
    
    public class CatsAndDogs {
        public static void main(String[] args) {
            Vector cats = new Vector();
            for (int i = 0; i < 7; i++)
                cats.addElement(new Cat(i));
            cats.addElement(new Dog(7));
            for (int i = 0; i < cats.size(); i++) {
                if(cats.elementAt(i) instanceof Cat) {//instanceof指出对象是否是cat类
                    ((Cat) cats.elementAt(i)).print();    
                }
                //((Cat) cats.elementAt(i)).print();//程序有未检查异常
        
            else {
                ((Dog) cats.elementAt(i)).print();//判断后若不是则返回dog类
            }
        }
    }
    }
    demo1

    示例程序2测试如下:

    import java.util.*;
    public class Stacks {
        static String[] months = { "1", "2", "3", "4" };
    
        public static void main(String[] args) {
            Stack stk = new Stack();
            for (int i = 0; i < months.length; i++)
                stk.push(months[i]);//入栈操作
            System.out.println(stk);
            System.out.println("element 2=" + stk.elementAt(2));
            //elementAt(2)该方法在没有list以前跟get方法的功能完全相同
            while (!stk.empty())
                System.out.println(stk.pop());//出栈操作
        }
    }
    demo2

    示例程序3运行如下:

    import java.util.*;
    
    class Counter {
        int i = 1;//权限
    
        public String toString() {
            return Integer.toString(i);
        }
    }
    public class Statistics {
        public static void main(String[] args) {
            Hashtable ht = new Hashtable();
            for (int i = 0; i < 10000; i++) {
                Integer r = new Integer((int) (Math.random() * 20));//random半开半闭区间0-19的数
                //Integer是int的封装类,将生成的数据转化成整型,让r去调用它
                if (ht.containsKey(r))
                    ((Counter) ht.get(r)).i++;//直接在类外部引用属性是因为i的访问权限是friendly
                //通过get方法通过键获得对应的value值
                else
                    ht.put(r, new Counter());//调用put方法使得哈希表创建一个新的键值对
            }
            System.out.println(ht);
        }
    }
    demo3

    测试程序2:

    l 使用JDK命令编辑运行ArrayListDemo和LinkedListDemo两个程序,结合程序运行结果理解程序;

    import java.util.*;

    public class ArrayListDemo {

    public static void main(String[] argv) {

    ArrayList al = new ArrayList();

    // Add lots of elements to the ArrayList...

    al.add(new Integer(11));

    al.add(new Integer(12));

    al.add(new Integer(13));

    al.add(new String("hello"));

    // First print them out using a for loop.

    System.out.println("Retrieving by index:");

    for (int i = 0; i < al.size(); i++) {

    System.out.println("Element " + i + " = " + al.get(i));

    }

    }

    }

    import java.util.*;

    public class LinkedListDemo {

        public static void main(String[] argv) {

            LinkedList l = new LinkedList();

            l.add(new Object());

            l.add("Hello");

            l.add("zhangsan");

            ListIterator li = l.listIterator(0);

            while (li.hasNext())

                System.out.println(li.next());

            if (l.indexOf("Hello") < 0)   

                System.err.println("Lookup does not work");

            else

                System.err.println("Lookup works");

       }

    }

     
    import java.util.*;
    public class ArrayListDemo {
        public static void main(String[] argv) {
            ArrayList al = new ArrayList();//ArrayList类生成一个数组由a1调用使用
            // Add lots of elements to the ArrayList...
            al.add(new Integer(11));
            //integer是与int不同的数据类型,往ArrayList中放东西时,像int这种内建类型是放不进去的。
            al.add(new Integer(12));
            al.add(new Integer(13));
            al.add(new String("hello"));
            // First print them out using a for loop.
            System.out.println("Retrieving by index:");
            for (int i = 0; i < al.size(); i++) {
                System.out.println("Element " + i + " = " + al.get(i));//已有list,可直接用get方法
            }
        }
    }
    ArrayListDemo

    import java.util.*;
    public class LinkedListDemo {//以双向链表的形式完成操作
         public static void main(String[] argv) {
                LinkedList l = new LinkedList();
                l.add(new Object());
                l.add("Hello");
                l.add("zhangsan");
                ListIterator li = l.listIterator(0);//listIterator(迭代器)用来遍历集合
                while (li.hasNext())
                    System.out.println(li.next());
                if (l.indexOf("Hello") < 0)   
                    System.err.println("Lookup does not work");
                else
                    System.err.println("Lookup works");
           }
    }
    LinkedListDemo

    l 在Elipse环境下编辑运行调试教材360页程序9-1,结合程序运行结果理解程序;

    l 掌握ArrayList、LinkList两个类的用途及常用API。

    package linkedList;
    
    import java.util.*;
    
    /**
     * This program demonstrates operations on linked lists.
     * @version 1.11 2012-01-26
     * @author Cay Horstmann
     */
    public class LinkedListTest
    {
       public static void main(String[] args)
       {
          List<String> a = new LinkedList<>();//创建一个泛型类型,使得a能引用它
          a.add("Amy");
          a.add("Carl");
          a.add("Erica");
    
          List<String> b = new LinkedList<>();
          b.add("Bob");
          b.add("Doug");
          b.add("Frances");
          b.add("Gloria");
    
          // merge the words from b into a
    
          ListIterator<String> aIter = a.listIterator();//遍历a中的所有元素,且a中元素为string类
          Iterator<String> bIter = b.iterator();
    
          while (bIter.hasNext())
          {
             if (aIter.hasNext()) aIter.next();
             aIter.add(bIter.next());
          }
    
          System.out.println(a);
    
          // remove every second word from b
    
          bIter = b.iterator();
          while (bIter.hasNext())
          {
             bIter.next(); // skip one element
             if (bIter.hasNext())
             {
                bIter.next(); // skip next element
                bIter.remove(); // remove that element
             }
          }
    
          System.out.println(b);
    
          // bulk operation: remove all words in b from a
    
          a.removeAll(b);
    
          System.out.println(a);
       }
    }
    LinkedListTest

    测试程序3:

    l 运行SetDemo程序,结合运行结果理解程序;

    import java.util.*;

    public class SetDemo {

        public static void main(String[] argv) {

            HashSet h = new HashSet(); //也可以 Set h=new HashSet()

            h.add("One");

            h.add("Two");

            h.add("One"); // DUPLICATE

            h.add("Three");

            Iterator it = h.iterator();

            while (it.hasNext()) {

                 System.out.println(it.next());

            }

        }

    }

    import java.util.*;
    public class SetDemo {
         public static void main(String[] argv) {
                HashSet h = new HashSet(); //也可以 Set h=new HashSet()
                h.add("One");
                h.add("Two");
                h.add("One"); // DUPLICATE
                h.add("Three");
                Iterator it = h.iterator();
                while (it.hasNext()) {
                     System.out.println(it.next());
                }
         }
    }
    setdemo

    l 在Elipse环境下调试教材365页程序9-2,结合运行结果理解程序;了解HashSet类的用途及常用API。

    package set;
    
    import java.util.*;
    
    /**
     * This program uses a set to print all unique words in System.in.
     * @version 1.12 2015-06-21
     * @author Cay Horstmann
     */
    public class SetTest
    {
       public static void main(String[] args)
       {
          Set<String> words = new HashSet<>(); // HashSet implements Set
          long totalTime = 0;
    
          try (Scanner in = new Scanner(System.in))
          {
             while (in.hasNext())
             {
                String word = in.next();
                long callTime = System.currentTimeMillis();
                words.add(word);
                callTime = System.currentTimeMillis() - callTime;
                totalTime += callTime;
             }
          }
    
          Iterator<String> iter = words.iterator();
          for (int i = 1; i <= 20 && iter.hasNext(); i++)
             System.out.println(iter.next());
          System.out.println(". . .");
          System.out.println(words.size() + " distinct words. " + totalTime + " milliseconds.");
       }
    }
    set 

    l 在Elipse环境下调试教材367页-368程序9-3、9-4,结合程序运行结果理解程序;了解TreeSet类的用途及常用API。

    package treeSet;
    
    import java.util.*;
    
    /**
     * An item with a description and a part number.
     */
    public class Item implements Comparable<Item>
    {
       private String description;
       private int partNumber;
    
       /**
        * Constructs an item.
        * 
        * @param aDescription
        *           the item's description
        * @param aPartNumber
        *           the item's part number
        */
       public Item(String aDescription, int aPartNumber)
       {
          description = aDescription;
          partNumber = aPartNumber;
       }
    
       /**
        * Gets the description of this item.
        * 
        * @return the description
        */
       public String getDescription()
       {
          return description;
       }
    
       public String toString()
       {
          return "[description=" + description + ", partNumber=" + partNumber + "]";
       }
    
       public boolean equals(Object otherObject)
       {
          if (this == otherObject) return true;
          if (otherObject == null) return false;
          if (getClass() != otherObject.getClass()) return false;
          Item other = (Item) otherObject;
          return Objects.equals(description, other.description) && partNumber == other.partNumber;
       }
    
       public int hashCode()
       {
          return Objects.hash(description, partNumber);
       }
    
       public int compareTo(Item other)
       {
          int diff = Integer.compare(partNumber, other.partNumber);
          return diff != 0 ? diff : description.compareTo(other.description);
       }
    }
    item
    package treeSet;
    
    import java.util.*;
    
    /**
     * This program sorts a set of item by comparing their descriptions.
     * @version 1.12 2015-06-21
     * @author Cay Horstmann
     */
    public class TreeSetTest
    {
       public static void main(String[] args)
       {
          SortedSet<Item> parts = new TreeSet<>();
          parts.add(new Item("Toaster", 1234));
          parts.add(new Item("Widget", 4562));
          parts.add(new Item("Modem", 9912));
          System.out.println(parts);
    
          NavigableSet<Item> sortByDescription = new TreeSet<>(
                Comparator.comparing(Item::getDescription));
    
          sortByDescription.addAll(parts);
          System.out.println(sortByDescription);
       }
    }
    tree

    测试程序4:

    l 使用JDK命令运行HashMapDemo程序,结合程序运行结果理解程序;

    import java.util.*;

    public class HashMapDemo {

       public static void main(String[] argv) {

          HashMap h = new HashMap();

          // The hash maps from company name to address.

          h.put("Adobe", "Mountain View, CA");

          h.put("IBM", "White Plains, NY");

          h.put("Sun", "Mountain View, CA");

          String queryString = "Adobe";

          String resultString = (String)h.get(queryString);

          System.out.println("They are located in: " +  resultString);

      }

    }

    测试程序:

    import java.util.*;
    public class HashMapDemo {
         public static void main(String[] argv) {
              HashMap h = new HashMap();
              // The hash maps from company name to address.
              h.put("Adobe", "Mountain View, CA");
              h.put("IBM", "White Plains, NY");
              h.put("Sun", "Mountain View, CA");
              String queryString = "Adobe";//访问指定的关键字Adobe
              String resultString = (String)h.get(queryString);
              System.out.println("They are located in: " +  resultString);
              
          }
    }
    HashMapDemo

    l 在Elipse环境下调试教材373页程序9-6,结合程序运行结果理解程序;

    l 了解HashMap、TreeMap两个类的用途及常用API。

    package map;
    
    /**
     * A minimalist employee class for testing purposes.
     */
    public class Employee
    {
       private String name;
       private double salary;
    
       /**
        * Constructs an employee with $0 salary.
        * @param n the employee name
        */
       public Employee(String name)
       {
          this.name = name;
          salary = 0;
       }
    
       public String toString()
       {
          return "[name=" + name + ", salary=" + salary + "]";
       }
    }
    employee
    package map;
    
    import java.util.*;
    
    /**
     * This program demonstrates the use of a map with key type String and value type Employee.
     * @version 1.12 2015-06-21
     * @author Cay Horstmann
     */
    public class MapTest
    {
       public static void main(String[] args)
       {
          Map<String, Employee> staff = new HashMap<>();
          staff.put("144-25-5464", new Employee("Amy Lee"));
          staff.put("567-24-2546", new Employee("Harry Hacker"));
          staff.put("157-62-7935", new Employee("Gary Cooper"));
          staff.put("456-62-5527", new Employee("Francesca Cruz"));
    
          // print all entries
    
          System.out.println(staff);
    
          // remove an entry
    
          staff.remove("567-24-2546");
    
          // replace an entry
    
          staff.put("456-62-5527", new Employee("Francesca Miller"));
    
          // look up a value
    
          System.out.println(staff.get("157-62-7935"));
    
          // iterate through all entries
    
          staff.forEach((k, v) -> 
             System.out.println("key=" + k + ", value=" + v));
       }
    }
    map

    实验2:结对编程练习:

    l 关于结对编程:以下图片是一个结对编程场景:两位学习伙伴坐在一起,面对着同一台显示器,使用着同一键盘,同一个鼠标,他们一起思考问题,一起分析问题,一起编写程序。

    l 关于结对编程的阐述可参见以下链接:

    http://www.cnblogs.com/xinz/archive/2011/08/07/2130332.html

    http://en.wikipedia.org/wiki/Pair_programming

    l 对于结对编程中代码设计规范的要求参考:

    http://www.cnblogs.com/xinz/archive/2011/11/20/2255971.html

    以下实验,就让我们来体验一下结对编程的魅力。

    l 确定本次实验结对编程合作伙伴;

    合作伙伴:李婷华

    l 各自运行合作伙伴实验九编程练习1,结合使用体验对所运行程序提出完善建议;

     伙伴的代码及运行结果:

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Scanner;
    import java.util.Collections;//对集合进行排序、查找、修改等;
    
    public class Test {
        private static ArrayList<Citizen> citizenlist;
    
        public static void main(String[] args) {
            citizenlist = new ArrayList<>();
            Scanner scanner = new Scanner(System.in);
            File file = new File("E:/java/身份证号.txt");
            //异常捕获
            try {
                FileInputStream fis = new FileInputStream(file);
                BufferedReader in = new BufferedReader(new InputStreamReader(fis));
                String temp = null;
                while ((temp = in.readLine()) != null) {
    
                    Scanner linescanner = new Scanner(temp);
    
                    linescanner.useDelimiter(" ");
                    String name = linescanner.next();
                    String id = linescanner.next();
                    String sex = linescanner.next();
                    String age = linescanner.next();
                    String birthplace = linescanner.nextLine();
                    Citizen citizen = new Citizen();
                    citizen.setName(name);
                    citizen.setId(id);
                    citizen.setSex(sex);
                    // 将字符串转换成10进制数
                    int ag = Integer.parseInt(age);
                    citizen.setage(ag);
                    citizen.setBirthplace(birthplace);
                    citizenlist.add(citizen);
    
                }
            } catch (FileNotFoundException e) {
                System.out.println("信息文件找不到");
                e.printStackTrace();
            } catch (IOException e) {
                System.out.println("信息文件读取错误");
                e.printStackTrace();
            }
            boolean isTrue = true;
            while (isTrue) {
    
                System.out.println("1.按姓名字典序输出人员信息");
                System.out.println("2.查询最大年龄的人员信息、查询最小年龄人员信息");
                System.out.println("3.查询人员中是否查询人员中是否有你的同乡");
                System.out.println("4.输入你的年龄,查询文件中年龄与你最近人的姓名、身份证号、年龄、性别和出生地");
                System.out.println("5.退出");
                int nextInt = scanner.nextInt();
                switch (nextInt) {
                case 1:
                    Collections.sort(citizenlist);
                    System.out.println(citizenlist.toString());
                    break;
                case 2:
                    int max = 0, min = 100;
                    int m, k1 = 0, k2 = 0;
                    for (int i = 1; i < citizenlist.size(); i++) {
                        m = citizenlist.get(i).getage();
                        if (m > max) {
                            max = m;
                            k1 = i;
                        }
                        if (m < min) {
                            min = m;
                            k2 = i;
                        }
                    }
                    System.out.println("年龄最大:" + citizenlist.get(k1));
                    System.out.println("年龄最小:" + citizenlist.get(k2));
                    break;
                case 3:
                    System.out.println("出生地:");
                    String find = scanner.next();
                    String place = find.substring(0, 3);
                    for (int i = 0; i < citizenlist.size(); i++) {
                        if (citizenlist.get(i).getBirthplace().substring(1, 4).equals(place))
                            System.out.println("出生地" + citizenlist.get(i));
                    }
                    break;
                case 4:
                    System.out.println("年龄:");
                    int yourage = scanner.nextInt();
                    int near = peer(yourage);
                    int j = yourage - citizenlist.get(near).getage();
                    System.out.println("" + citizenlist.get(near));
                    break;
                case 5:
                    isTrue = false;
                    System.out.println("程序已退出!");
                    break;
                default:
                    System.out.println("输入有误");
                }
            }
        }
    
        public static int peer(int age) {
            int flag = 0;
            int min = 53, j = 0;
            for (int i = 0; i < citizenlist.size(); i++) {
                j = citizenlist.get(i).getage() - age;
                if (j < 0)
                    j = -j;
                if (j < min) {
                    min = j;
                    flag = i;
                }
            }
            return flag;
        }
    }
    test
    public class Citizen implements Comparable<Citizen> {
    
        private String name;
        private String id;
        private String sex;
        private int age;
        private String birthplace;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public int getage() {
            return age;
        }
    
        public void setage(int age) {
            this.age = age;
        }
    
        public String getBirthplace() {
            return birthplace;
        }
    
        public void setBirthplace(String birthplace) {
            this.birthplace = birthplace;
        }
    
        public int compareTo(Citizen other) {
            return this.name.compareTo(other.getName());
        }
    
        public String toString() {
            return name + "	" + sex + "	" + age + "	" + id + "	" + birthplace + "
    ";
        }
    }
    citizen

    l 各自运行合作伙伴实验十编程练习2,结合使用体验对所运行程序提出完善建议;

    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.Scanner;
    
    public class calculator {
    
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            Count count=new Count();
            PrintWriter out = null;
            try {
                out = new PrintWriter("test.txt");
                int sum = 0;
                for (int i = 1; i <=10; i++) {
                    int a = (int) Math.round(Math.random() * 100);
                    int b = (int) Math.round(Math.random() * 100);
                    int menu = (int) Math.round(Math.random() * 3);
                    switch (menu) {
                    case 0:
                        System.out.println(i+":"+a + "+" + b + "=");
                        int c1 = in.nextInt();
                        out.println(a + "+" + b + "=" + c1);
                        if (c1 == (a + b)) {
                            sum += 10;
                            System.out.println("恭喜答案正确");
                        } else {
                            System.out.println("抱歉,答案错误");
                        }
                        break;
                    case 1:
                        while (a < b) {
                            b = (int) Math.round(Math.random() * 100);
                        }
                        System.out.println(i+":"+a + "-" + b + "=");
                        int c2 = in.nextInt();
                        out.println(a + "-" + b + "=" + c2);
                        if (c2 == (a - b)) {
                            sum += 10;
                            System.out.println("恭喜答案正确");
                        } else {
                            System.out.println("抱歉,答案错误");
                        }
    
                        break;
                    case 2:
                        System.out.println(i+":"+a + "*" + b + "=");
                        int c3 = in.nextInt();
                        out.println(a + "*" + b + "=" + c3);
                        if (c3 == a * b) {
                            sum += 10;
                            System.out.println("恭喜答案正确");
                        } else {
                            System.out.println("抱歉,答案错误");
                        }
    
                        break;
                    case 3:
                         while(b == 0){
                                b = (int) Math.round(Math.random() * 100);
                            }
                            while(a % b != 0){
                                a = (int) Math.round(Math.random() * 100);
                                
                            }
                        System.out.println(i+":"+a + "/" + b + "=");
                        int c4 = in.nextInt();
                        if (c4 == a / b) {
                            sum += 10;
                            System.out.println("恭喜答案正确");
                        } else {
                            System.out.println("抱歉,答案错误");
                        }
    
                        break;
                    }
                }
                System.out.println("你的得分为" + sum);
                out.println("你的得分为" + sum);
                out.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    }
    calculate
    public class Count<T> {
        private T a;
        private T b;
        public Count() {
            a=null;
            b=null;
        }
        public Count(T a,T b) {
            this.a=a;
            this.b=b;
        }
        public int count1(int a,int b) {
            return a+b;
        }
        public int count2(int a,int b) {
            return a-b;
        }
        public int count3(int a,int b) {
            return a*b;
        }
        public int count4(int a,int b) {
            return a/b;
        }
    }
    count

    l 采用结对编程方式,与学习伙伴合作完成实验九编程练习1;

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;
    import java.util.Scanner;
    
    public class Xinxi {
        private static ArrayList<Student> studentlist;
    
        
        public static  void main(String[] args) {
            studentlist = new ArrayList<>();
            Scanner scanner = new Scanner(System.in);
            File file = new File("D:\身份证号\身份证号.txt");
            try {
                FileInputStream fis = new FileInputStream(file);
                BufferedReader in = new BufferedReader(new InputStreamReader(fis));
                String temp = null;
                while ((temp = in.readLine()) != null) {
    
                    Scanner linescanner = new Scanner(temp);
    
                    linescanner.useDelimiter(" ");
                    String name = linescanner.next();
                    String number = linescanner.next();
                    String sex = linescanner.next();
                    String age = linescanner.next();
                    String province = linescanner.nextLine();
                    Student student = new Student();
                    student.setName(name);
                    student.setnumber(number);
                    student.setsex(sex);
                    int a = Integer.parseInt(age);
                    student.setage(a);
                    student.setprovince(province);
                    studentlist.add(student);
    
                }
            } catch (FileNotFoundException e) {//添加的异常处理语句try{   }catch{   }语句
                System.out.println("所找信息文件找不到");
                e.printStackTrace();
            } catch (IOException e) {
                System.out.println("所找信息文件读取错误");//采取积极方法捕获异常,并将异常返回自己所设定的打印文字
                e.printStackTrace();
            }
            boolean isTrue = true;
            while (isTrue) {
                System.out.println("选择你的操作,输入正确格式的选项");
                System.out.println("1按姓名字典序输出人员信息");
                System.out.println("2.查询最大和最小年龄的人员信息");
    
                System.out.println("3.寻找年龄相近的人的信息");
                System.out.println("4.寻找老乡");
    
                System.out.println("5.退出");
                String n = scanner.next();
                switch (n) {
                case "1":
                    Collections.sort(studentlist);
                    System.out.println(studentlist.toString());
                    break;
                case "2":
                    int max = 0, min = 100;
                    int j, k1 = 0, k2 = 0;
                    for (int i = 1; i < studentlist.size(); i++) {
                        j = studentlist.get(i).getage();
                        if (j > max) {
                            max = j;
                            k1 = i;
                        }
                        if (j < min) {
                            min = j;
                            k2 = i;
                        }
    
                    }
                    System.out.println("年龄最大:" + studentlist.get(k1));
    
                    System.out.println("年龄最小:" + studentlist.get(k2));
                    break;
                case "3":
                    System.out.println("家乡在哪里?");
                    String find = scanner.next();
                    String place = find.substring(0, 3);
                    for (int i = 0; i < studentlist.size(); i++) {
                        if (studentlist.get(i).getprovince().substring(1, 4).equals(place))
                            System.out.println("同乡" + studentlist.get(i));
                    }
                    break;
    
                case "4":
                    System.out.println("年龄:");
                    int yourage = scanner.nextInt();
                    int near = agenear(yourage);
                    int value = yourage - studentlist.get(near).getage();
                    System.out.println("" + studentlist.get(near));
                    break;
                case "5":
                    isTrue = false;
                    System.out.println("退出程序!");
                    break;
                default:
                    System.out.println("输入有误");
    
                }
            }
        }
    
        public static int agenear(int age) {
            int j = 0, min = 53, value = 0, flag = 0;
            for (int i = 0; i < studentlist.size(); i++) {
                value = studentlist.get(i).getage() - age;
                if (value < 0)
                    value = -value;
                if (value < min) {
                    min = value;
                    flag = i;
                }
            }
            return flag;
        }
    
    }
    
    xinxi
    xinxi
    public  class Student implements Comparable<Student> {
    
        private String name;
        private String number;
        private String sex;
        private String province;
        private int age;
    
        public void setName(String name) {
            // TODO 自动生成的方法存根
            this.name = name;
    
        }
    
        public String getName() {
            // TODO 自动生成的方法存根
            return name;
        }
    
        public void setnumber(String number) {
            // TODO 自动生成的方法存根
            this.number = number;
        }
    
        public String getNumber() {
            // TODO 自动生成的方法存根
            return number;
        }
    
        public void setsex(String sex) {
            // TODO 自动生成的方法存根
            this.sex = sex;
        }
    
        public String getsex() {
            // TODO 自动生成的方法存根
            return sex;
        }
    
        public void setprovince(String province) {
            // TODO 自动生成的方法存根
            this.province = province;
        }
    
        public String getprovince() {
            // TODO 自动生成的方法存根
            return province;
        }
    
        public void setage(int a) {
            // TODO 自动生成的方法存根
            this.age = age;
        }
    
        public int getage() {
            // TODO 自动生成的方法存根
            return age;
        }
    
        public int compareTo(Student o) {
            return this.name.compareTo(o.getName());
        }
    
        public String toString() {
            return name + "	" + sex + "	" + age + "	" + number + "	" + province + "
    ";
        }
    }
    
    student类
    student

    l 采用结对编程方式,与学习伙伴合作完成实验十编程练习2。

    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.Scanner;
    
    public class calculator {
    
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            Count count=new Count();
            PrintWriter out = null;
            try {
                out = new PrintWriter("test.txt");
                int sum = 0;
                for (int i = 1; i <=10; i++) {
                    int a = (int) Math.round(Math.random() * 100);
                    int b = (int) Math.round(Math.random() * 100);
                    int menu = (int) Math.round(Math.random() * 3);
                    switch (menu) {
                    case 0:
                        System.out.println(i+":"+a + "+" + b + "=");
                        int c1 = in.nextInt();
                        out.println(a + "+" + b + "=" + c1);
                        if (c1 == (a + b)) {
                            sum += 10;
                            System.out.println("恭喜答案正确");
                        } else {
                            System.out.println("抱歉,答案错误");
                        }
                        break;
                    case 1:
                        while (a < b) {
                            b = (int) Math.round(Math.random() * 100);
                        }
                        System.out.println(i+":"+a + "-" + b + "=");
                        int c2 = in.nextInt();
                        out.println(a + "-" + b + "=" + c2);
                        if (c2 == (a - b)) {
                            sum += 10;
                            System.out.println("恭喜答案正确");
                        } else {
                            System.out.println("抱歉,答案错误");
                        }
    
                        break;
                    case 2:
                        System.out.println(i+":"+a + "*" + b + "=");
                        int c3 = in.nextInt();
                        out.println(a + "*" + b + "=" + c3);
                        if (c3 == a * b) {
                            sum += 10;
                            System.out.println("恭喜答案正确");
                        } else {
                            System.out.println("抱歉,答案错误");
                        }
    
                        break;
                    case 3:
                         while(b == 0){
                                b = (int) Math.round(Math.random() * 100);
                            }
                            while(a % b != 0){
                                a = (int) Math.round(Math.random() * 100);
                                
                            }
                        System.out.println(i+":"+a + "/" + b + "=");
                        int c4 = in.nextInt();
                        if (c4 == a / b) {
                            sum += 10;
                            System.out.println("恭喜答案正确");
                        } else {
                            System.out.println("抱歉,答案错误");
                        }
    
                        break;
                    }
                }
                System.out.println("你的得分为" + sum);
                out.println("你的得分为" + sum);
                out.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    }
    calculate
    public class Count<T> {
        private T a;
        private T b;
        public Count() {
            a=null;
            b=null;
        }
        public Count(T a,T b) {
            this.a=a;
            this.b=b;
        }
        public int count1(int a,int b) {
            return a+b;
        }
        public int count2(int a,int b) {
            return a-b;
        }
        public int count3(int a,int b) {
            return a*b;
        }
        public int count4(int a,int b) {
            return a/b;
        }
    }
    count

    综上所述:结对编程有很大的益处,对于有些个人能力限制及思考不到的问题,同伴合作总能产生一些新颖的想法,同时在自己不能修改自己的程序错误或没有思路的时候

    同伴总能给予一定的思路引导。

     实验总结:通过本周的学习我了解了新旧集合类的不同, 掌握了Vetor、Stack、Hashtable三个类的用途,了解了java集合框架体系组成;

    掌握ArrayList、LinkList两个类的用途及常用API。 对于HashSet类、TreeSet类的用途以及HashMap、TreeMap两个类的用途尚且理解不是很到位。

    初步对结对练习编程有了了解,并与我的同伴互相对实验九的编程进行了阅读并对我们的写程序的思想互相分享,并相互借鉴对方比较新颖的思路。

     

     

  • 相关阅读:
    www.insidesql.org
    kevinekline----------------- SQLSERVER MVP
    Sys.dm_os_wait_stats Sys.dm_performance_counters
    如何使用 DBCC MEMORYSTATUS 命令来监视 SQL Server 2005 中的内存使用情况
    VITAM POST MORTEM – ANALYZING DEADLOCKED SCHEDULERS MINI DUMP FROM SQL SERVER
    Cargo, Rust’s Package Manager
    建筑识图入门(初学者 入门)
    Tracing SQL Queries in Real Time for MySQL Databases using WinDbg and Basic Assembler Knowledge
    Microsoft SQL Server R Services
    The Rambling DBA: Jonathan Kehayias
  • 原文地址:https://www.cnblogs.com/li-xiaojing/p/9930442.html
Copyright © 2011-2022 走看看