aaa

package com.itheima;

/*    需求：    
 *         1、取出一个字符串中字母出现的次数。
 *         如：字符串："abcdekka27qoq" ，输出格式为：a(2)b(1)k(2)...
 *  思路：
 *      从输出结果来看，对字符串各字符进行了排序且建立了映射关系。
 *      所以用TreeMap集合来存储字符串的所有字符.
 *      首先将字符串转换为字符数组，并根据算法条件判定写入TreeMap集合中。这一步可以封装为stringToMap方法。
 *         然后，将TreeMap集合按规定格式转换为字符串并返回，这一步封装为mapToString方法。
 *         将这两个方法综合起来则构成了总的方法即stringSort方法，返回格式要求的字符串。
 *         打印。
 */
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Test1 {

    public static void main(String[] args) {
        
        
        String s = "wojiaofanjiananhahaha";
        System.out.println(sortString(s));
    }
    
    public static String sortString(String s) {  //sortString方法，调用以下两个方法。
        
        
        return mapToString(stringToMap(s));
        
        
        
        
    }
    //stringToMap方法是将字符串中的字符按照TreeMap<a,3>的格式写入Map集合并返回。
    public static TreeMap stringToMap (String s){
        
        TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
        
        char[] ch = s.toCharArray();   //将字符串转换为字符数组
                            
        
        for(char i : ch) {               //遍历字符数组，高级for循环
            
            if(!tm.containsKey(i))    //如果Map集合中没有字符i键,则初始化Map值为1。否则值+1
                tm.put(i, 1);
                
            else{
                tm.put(i,tm.get(i)+1);  
            }
            
        }
        return tm;          
    }
    
    //该方法把的集合元素取出，转换为规定格式字符串
    public static String mapToString(TreeMap tm) {
        
        
        //Set集合存储Map元素的映射关系
        Set<Map.Entry<Character, Integer>> set = tm.entrySet();  
        
        StringBuilder sb = new StringBuilder();
        //遍历Set集合
        for(Iterator<Map.Entry<Character,Integer>> it = set.iterator();it.hasNext();) {
            
            //利用Map.Entry的getKey()和getValue()方法取出键和值
            Map.Entry<Character, Integer>  me = it.next();
            sb.append(me.getKey()+"("+me.getValue()+")");
            
        }
        //利用容器StringBuilder转换为字符串
        String s2 =sb.toString();
        
        return s2;
    }

}

package com.itheima;

/* 需求：
 *         10、28人买可乐喝，
 *         3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，
 *         够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）
 * 
 * 思路：  
 *         流程分析：瓶盖可以换可乐，可乐的瓶盖加上没有换的瓶盖又可以换可乐，循环来进行。
 *            这个循环流程中有以下变量：
 *         colacap:瓶盖的数量  colaswap :瓶盖换取可乐后的数量  swaptotal 总共换取可乐的数量
 *         
 * 
 * 答案： 买34瓶可乐，可以供50个刃喝
 *                买19瓶可乐，够28个刃喝。
 */
public class Test10 {

    public static void main(String[] args) {
        
        
        
        
        System.out.println(firstBuy(28));
        System.out.println(firstBuy(50));
        
        
        
    
}    
    
    //此方法用于得到够N个人喝，需要购买的可乐数量。
    public static int firstBuy(int n) {
        
        int colacap = 0;
        while(colacap + buyToSwap(colacap) != n ) { //条件判定，购买的可乐加上换取的可乐不等于总人数，则继续循环
            
            colacap++;
        }
        
        
        return colacap;  //返回最初购买的可乐数
        
    }
    //此方法用于计算够买n瓶可乐，可以换取可乐的总数。，
    public static int buyToSwap (int colacap){
        
        int colaswap  = colacap / 3;;  //瓶盖/3 为一次可以换取可乐的数量
        int swaptotal = colaswap;       //换取的总数量
        
        while(colacap > 3 ) {     //循环
            
            
            colacap = colaswap +colacap % 3;  //换取可乐后剩下的瓶盖总量
            colaswap = colacap / 3;            // 瓶盖又可以换取可乐
            swaptotal = swaptotal+ colaswap; //换取可乐的总数
            
            
            
            
            
            
        }
        return swaptotal;  //返回n个瓶盖换取可乐的总数
        
        
        
    }

}

package com.itheima;

/*需求：
 *         一个ArrayList对象aList中存有若干个字符串元素，
 *         现欲遍历该ArrayList对象，
 *         删除其中所有值为"abc"的字符串元素，请用代码实现。
 *思路：
 *           删除ArrayList中的元素有一个问题，就是如果调用List本身的删除方法，
 *           删除元素集合长度变化引起索引变化，会影响遍历。
 *           可以通过Iterator遍历并使用Iterator的remove()方法实现删除元素
 * 
 */
import java.util.ArrayList;
import java.util.Iterator;

public class Test2 {
    public static void main(String[] args) {
        
        ArrayList<String> alist = new ArrayList<String>();
        
        alist.add("hello");
        alist.add("world");
        alist.add("abc");
        alist.add("heima");
        alist.add("programer");
        alist.add("abc");
        
        System.out.println(alist);  //打印原集合
        
        removeElements(alist,"abc"); //调用删除指定元素方法。
        
        System.out.println(alist);    //打印删除元素后的集合，做对比
        
        
        
        
    }
    
    /*此方法按照需求删除指定元素，并返回一个集合*/
    public static ArrayList<String> removeElements(ArrayList alist,String s) {
        
        
        Iterator<String> it = alist.iterator();  //规定迭代器中只存储字符串元素
        while(it.hasNext()) {                    //遍历集合
            
            String s1 = it.next();
        
            if(s1.equals(s))
                it.remove();  //调用迭代器本身的remove方法删除元素
            
        }
        
        return alist;
    }

}

package com.itheima;

/*需求： 
 *         编写一个类，在main方法中定义一个Map对象（采用泛型），
 *         加入若干个对象，然后遍历并打印出各元素的key和value。
 * 思路
 *         用HashMap存储Key和Value,键为Heimaer类，值为String
 *         由于是HashMap则应该重写类中的hashCode()和equals方法
 *         建立Map.Entry作为元素的映射关系集合
 *         遍历集合调用.getKey()和.getValue()方法获取键值并打印。
 */
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test3 {

    public static void main(String[] args) {
        
        HashMap<Heimaer,String> hm = new HashMap<Heimaer,String>();
        
        //添加Map集合元素
        hm.put(new Heimaer(1,"fanjianan"),"Andriod");
        hm.put(new Heimaer(2,"joyce"),"Andriod");
        hm.put(new Heimaer(3,"lennon"),"Andriod");
        hm.put(new Heimaer(4,"jobs"),"IOS");
        hm.put(new Heimaer(5,"gates"),"C++");
        
        //调用printMap方法打印集合元素
        printMap(hm);
        
    }
    
    /*此方法用于打印集合元素*/
    public static void printMap(HashMap hm) {
        //Set集合存放映射关系Map.Entry
        Set<Map.Entry<Heimaer,String>> s = hm.entrySet();
        Iterator<Map.Entry<Heimaer,String>> it = s.iterator();
        //迭代器遍历Set集合获取Map.Entry元素
        while(it.hasNext()) {
            
            Map.Entry<Heimaer,String> me = it.next();
            //打印键值
            System.out.println("Student:.."+me.getKey()+"\tMajoy:..."+me.getValue());
        }
        
    }

}

/*此类为自定义类，描述黑马学员，作为Map集合的键*/
class Heimaer {
    
    private int id;
    private String name;
    
    Heimaer(int id ,String name) {
        this.id = id;
        this.name = name;
    }
    //重写hashCode()方法
    public int hashCode() {  
        
        return this.id+100;
    }
    //重写equals()方法
    public boolean equals(Object obj) {  
        
        if(!(obj instanceof Heimaer)) {
            new RuntimeException("无法比较不同类型");
            return false;
        }
        
        Heimaer h2 = (Heimaer)obj;
        return (this.id == h2.id) && (this.name.equals(h2.name));    
        
    }
    //重写toString方法
    public String toString() {
        
        return this.id +"---"+ this.name;
    }
    
    public String getName() {
        return this.name;
    }
    public int getID() {
        return this.id;
    }
    public void setName() {
        this.name = name;
    }
    public void setID(int id) {
        this.id = id;
    }
    
    
}

package com.itheima;

/*题目：
 *        分析运行结果，说明原理。(没有分析结果不得分) 
 *答: 
 *    程序结果为  102
 *           102
 *           102
 *     分析：我们可以从程序中看出，只new出一个Data类的对象，
 *         因此ArrayList中存放的3个元素都是一样的，都是指向data的引用。
 *         循环中data.val = i 则改变了这个对象的成员变量val.
 *         因此无论循环多少次，这个对象中的val的值，都是最后一次循环i赋予的值。
 *         因此打印的结果都是这个对象的val，都是102.
 */
import java.util.ArrayList;

class Data {

   int val;

}

public class Test4 {

    public static void main(String args[]) {
        Data data = new Data();        //注意：此处仅仅只new了一个对象
        ArrayList<Data> list = new ArrayList<Data>();
    
        for (int i = 100; i < 103; i++) {
            data.val = i;    //改变该data对象的值为i
            list.add(data);  //把该对象的引用作为元素加入集合，集合中加入的都是同一个对象
        }
    
        for (Data d : list) {
            System.out.println(d.val);  //d.val的值是一样的，因为是同一个对象的值值未最后一次循环赋予的值，102
        }
    }
}

package com.itheima;

/* 需求：
 *         把以下IP存入一个txt文件，编写程序把这些IP按数值大小，从小到达排序并打印出来。
        61.54.231.245
        61.54.231.9
        61.54.231.246
        61.54.231.48
        61.53.231.249
 * 思路：      
 *         首先建立流对象BufferedReader读取ip.txt文件，循环获取每一行字符串。
 *         获取一行字符串后，用正则表达式把ip地址的所有分段变成3位数，高位补0.
 *         将转换后的字符串加入TreeSet集合中，自动排序
 *         遍历TreeSet集合，将每一个字符串元素用正则表达式还原后打印。
 * 
 */

import java.io.*;
import java.util.Iterator;
import java.util.TreeSet;
public class Test5 {

    public static void main(String[] args) {
        
        
        File f = new File("F:\\ip.txt");    //创建File对象，关联ip地址文件
        TreeSet<String> ts = fileIPtoSet(f); //调用方法，将文件内的ip地址格式转换后存入集合ts
        printSetIP(ts);                        //按原格式打印排序后的ip地址
        
        
        
        
                    
    }
    /*此方法将ip.txt的所有ip地址转换为XXX.XXX.XXX.XXX格式，并放入TreeSet集合中排序，返回该集合*/
    public static TreeSet<String> fileIPtoSet(File f) {
        
        TreeSet<String> ts = new TreeSet<String>();
        String line = null;
        String ip = null;
        
        try {
            
            BufferedReader br = new BufferedReader(new FileReader(f));
            while((line = br.readLine()) != null) {
                
                ip = line.replaceAll("(\\d+)","00$1");  //将所有ip段高位补两个0，
                ip = ip.replaceAll("0+(\\d{3})", "$1"); //去掉多余的0，保留3位
                //System.out.println(ip);
                ts.add(ip);                                //将统一格式的ip放入TreeSet集合中排序
            }
            
            br.close();
        } 
        
        catch (IOException e) {
            new RuntimeException("读入文件失败");
        }
        
        
        return ts;
    }
    
    
    /*此方法将集合中的所有ip转换成原格式并打印*/
    public static void printSetIP (TreeSet ts) {

        Iterator<String> it = ts.iterator();  //遍历Set集合
        String line = null;
        while(it.hasNext()) {
            line = it.next();
            
            line = line.replaceAll("0+([1-9]+)", "$1"); //去掉ip段的高位0
            System.out.println(line);                     //打印集合元素
        }

    }
}

package com.itheima;

/*需求：
 *         编写程序，生成5个1至10之间的随机整数，
 *         存入一个List集合，编写方法对List集合进行排序
 *         （自定义排序算法，禁用Collections.sort方法和TreeSet），然后遍历集合输出。
 * 思路：
 *         1。调用Random类的实例获取随机数，自动装箱为Integer类型加入ArrayList中。
 *         2.对ArrayList中的元素进行排序。两种思路：可以将ArrayList转换为数组，也可以直接对元素进行compareTo比较
 *                本程序用的是对象比较方法，目的是提高程序的扩展性。
 *         3.打印ArrayList中的元素。
 * 
 */
import java.awt.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;

public class Test6 {

    public static void main(String[] args) {
        
        ArrayList<Integer> list =new ArrayList<Integer>();  //创建集合对象
        
        //创建Randowm对象，循环5次，调用nextInt(10)+1获取1-10的随机数
        Random r = new Random();  
        for(int i = 0;i<5;i++) {
            list.add(r.nextInt(10) + 1 );
            //System.out.println(list.get(i));
        }
        
        //打印集合
        printArrayList(list);
        //调用arrayListSort方法对集合排序
        arrayListSort(list);
        printArrayList(list);
    
        
        
    }
    //此方法是集合排序方法，运用了冒泡排序方法。
    public static ArrayList arrayListSort(ArrayList<Integer> list) {
        
        Integer temp;
        
        //冒泡排序算法，双重循环，利用对象的compareTo方法比较相邻元素的大小
        for(int i = 0;i<list.size() - 1;i++) {
            for(int j = 0 ;j<list.size() - i -1;j++) {
                if(list.get(j).compareTo(list.get(j+1)) > 0) {
                    
                    //相邻元素互换。
                    temp = list.get(j);
                    list.set(j, list.get(j+1));
                    list.set(j+1, temp);
                    
                }
                
            }
        }
        return list;
        
    }
    
    //此方法用于打印集合中的元素
    public static void printArrayList(ArrayList list) {
        
        //Iterator迭代器遍历集合，打印元素，形式为[元素]
        Iterator it = list.iterator();
        while(it.hasNext()) {
            
            System.out.print("["+it.next()+"]"+"\t");
        }
        System.out.println();
    }

}

package com.itheima;
/*客户端思路：
 *         1.创建Socket对象，指定ServerIP地址和端口。
 *         2.调用s.getInputStream/OutputStream获取网络IO流对象
 *         3.创建本地流对象关联目标文件。
 *         4.调用本地流对象的read()方法读取数据，并写入网络的输出流中。
 *         5.等待服务器返回信息。 
 */



import java.io.*;
import java.net.*;
public class Test7Client {

    public static void main(String[] args) {
        
        File f = new File("F:\\abc.jpg");
        try {
            
            //指定Server IP地址和端口号
            Socket s = new Socket("192.168.1.101",10003);
            
            //本地输入流，用于读取目标文件
            FileInputStream localis = new FileInputStream(f);
            
            //网络输入输出流
            OutputStream os = s.getOutputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
            
            //读取本地文件并写入网络输出流
            byte[] temp = new byte[1024*1024];
            int len = 0;
            while((len = localis.read(temp))!= -1) {
                
                os.write(temp,0,len);
                
            }
            
            //标记，传输完成
            s.shutdownOutput();
            //打印服务器返回信息
            System.out.println(br.readLine());
            s.close();
            
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            new RuntimeException("上传失败！");
        }

    }

}

package com.itheima;

/*需求：
 *         使用TCP协议写一个可以上传文件的服务器和客户端。
 *思路：
 *        Server端：1.创建ServerSocket对象，指定Server端口。
 *                2.一个服务器应该可以多个客户端同时访问，故应用多线程技术。
 *                3.创建Upload类实现Runnable接口。定义线程。
 *                4.重写run方法。run方法中实现和Client端的IO通信。
 *                5.程序以上传F盘符下的abc.jpg为例。
 *            
 * 
 * 
 */
import java.net.*;
import java.io.*;


public class Test7Server {
    public static void main(String[] args) throws Exception {
        
        
        ServerSocket ss = new ServerSocket(10003);
        //服务器监听机制，一旦获取Client的Socket则开启线程、
        while(true) {
            
            new Thread(new Upload(ss.accept())).start();
            
        }
        
        
        
    }
}

class Upload implements Runnable {  //线程Upload实现上传功能
    
    
    private Socket s;
    
    Upload(Socket s) {
        this.s = s;
    }
    public void run() {
        
        try {
                
                //网络IO流对象，用于和Client端进行通信
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
                InputStream is = s.getInputStream();
                
                File f = new File("F:\\abc.jpg"); //创建文件
                int count = 0;
                while(f.exists()) {  //重复改名
                    f = new File("F:\\abc("+(++count) +").jpg");
                }
                
                //Server本地输出流。用于创建本地文件
                FileOutputStream os = new FileOutputStream(f);
                
                //字节数组缓冲区
                byte[] temp = new byte[1024*1024];
                int len;
                
                //循环写入文件
                while((len = is.read(temp)) != -1) {
                    
                    os.write(temp,0,len);
                }
                
                
                
                String ip = s.getInetAddress().getHostAddress();   //获取客户端ip地址
                bw.write(new String("ip:...."+ip+ "Upload Down")); //上传成功后返回上传信息
                bw.flush();
                bw.close();
                
                os.close();
                s.close();
                
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        
    }
}

package com.itheima;
/*需求：
 *         写一方法，打印等长的二维数组，
 *         要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 
 *         如： n = 4 则打印：
 *思路：      由题目可知，需要螺旋式打印一个二维数组，
 *        我们用递归的思想，把这个数组分圈打印，由外到内的打印。
 *        而每一圈有四种情况，上右下左。
 *        根据上述特点找出数据间的关系。

 * 
 */

public class Test8 {

    public static void main(String[] args) {
          
                arraynum(6);  
    }  
      
    //便于改代码..输入不同y值输出不同的二维数列  
    public static void arraynum(int y)  {
        
                int[][] arr=new int[y][y];  
                int n = arr.length;  
                int max = 0;  //max是一个变量，根据程序流程自加后赋予数组元素
                int count = 0;  
                fillArr(arr,n,max,count);  
                printArr(arr);  
    }  
      
    //两层循环打印二维数组.
    public static void printArr(int[][] superArr) {  
           
        for(int[] inerArr : superArr)  {
                  
            for(int elements : inerArr)  {
                
                
                //因为个位数喝二位数所占的空间补同，所以这里用于统一格式，使得打印更美观
                if(elements<10)                     
                    System.out.print(" "+elements+" ");  
                 else                  
                    System.out.print(elements+" ");      
             }  
             System.out.println();  
        }                  
                      
    }                   
         

    public static void fillArr(int[][] arr,int n,int max,int count) {  //填充螺旋数组，n为每圈元素的边界个数
                  
        
        if(n>0) {
            int j=0;  
            for(int i=0;i<(n-1)*4;i++)  { //打印外圈   (len-1)*4是外圈元素的个数
            
            
                //打印上边界的n-1个元素
                if (i<n-1)  
                    arr[0+count][i+count]=  ++max;  
           //打印右边界
                else if (i<2*n-2) 
                    arr[count+j++][arr.length-1-count] = ++max;  
           //打印下边界
                else if (i<3*n-3)
                    arr[arr.length-1-count][(j--)+count] = ++max; 
           //打印左边界
                else if (i<4*n-4)
                    arr[arr.length-1-(j++)-count][0+count] = ++max;                          
        }  
        //补充条件： 当y值为奇数时,会有循环到n=1的情况,需要补进数组最中间值  
        if(n==1) {
            arr[arr.length/2][arr.length/2] = max+1 ;
        }
        
        count++;  
        n -= 2; //下一圈
        fillArr(arr,n,max,count);  //递归调用
    }  
    }    
                  

      
}           

package com.itheima;


/*需求 ： 
 *         有100个人围成一个圈，从1开始报数，
 *         报到14的这个人就要退出。然后其他人重新开始，
 *         从1报数，到14退出。问：最后剩下的是100人中的第几个人？
 *思路：    1.初始化ArrayList数组，循环添加1-100个Integer对象。
 *        2.利用迭代器，遍历集合，当计数器count ==14后，利用iterator.remove()方法删除该元素。
 *        3.当itrator.hasNext()值未false时，初始化迭代器，it = al.iterator();
 *        4.限定条件，集合元素剩下一个的时候，停止。
 *        5.打印该元素
 * 
 * 结果：  92
 * 
 */
import java.util.ArrayList;
import java.util.Iterator;


public class Test9 {

    public static void main(String[] args) {

        //调用addArrayList方法，获取一个长度为100的集合，元素为1-100；
        ArrayList<Integer> al =addArrayList(100); 
        //调用lastOne方法，获取最后一个元素，相当于人的编号。
        int i =lastOne(al);
        System.out.println(i);
        
        
        
        
            
    }
    
    
    //此方法用于初始化一个长度为N,元素为1-N的ArrayList
    public static ArrayList addArrayList (int n) {
        
        ArrayList <Integer>al = new ArrayList<Integer>();
        
        for(int i = 0;i<n;i++) {  //循环n此，加入1---n元素
            al.add(i+1);
        }
        
        return al;   //返回集合
    }
    
    public static int lastOne(ArrayList<Integer> al) {
        
        int count = 0;    //初始化计数器
        Iterator<Integer> it = al.iterator();
        
        
    while(al.size() != 1 ){   //当集合元素的个数不为1时候，持续循环
        
            
            while(it.hasNext()) {   //内循环判定条件，相当于一次从1数到头
                it.next();            
                count++;        
                
                if(count == 14) {  //当数到14时，去除该元素
                    it.remove(); 
                    count = 0;
                }
                    

            }
            it = al.iterator();  //初始化迭代器，从头开始迭代
        }
        
        return it.next();  //返回最后一个元素
    }

}