java基础代码

package com.sxf;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;

public class Demo {
    public void say(){
        System.out.println("this is father say");
    }
    public void walk(){
        System.out.println("this is a father walker");
    }
    interface Action {
        public  abstract void  readerbooks();
        public static final String  name="shixinfa";
        public static  void means(){
            System.out.println("this is menas");
        }
    }
     interface soninterface extends Action{
         default void means(){
                System.out.println("this is son menas");
         }
         @Override
        default void readerbooks() {
             System.out.print("看书");
            
        }
     }
     static class Son extends Demo implements Action{
         //构造函数只在初始化的时候被初始化一次，以后运行
        public Son(){
            System.out.println("这是儿子");
        }
        @Override
        public void say() {
            super.say();
            System.out.println("this is son say");    
        }
        @Override
        public void walk() {
            super.walk();
            System.out.println("this is son walk");
        }
        //接口中的方法被覆盖了，没有展示出来。
        @Override
        public void readerbooks() {
            System.out.println("方法被继承实现了");
            
        }
    }
    public static void main(String[] args) throws Exception {
        //
         Son son=new Son();
         son.say();
         son.walk();
         son.readerbooks();
    }

    // 字符串的操作
    public static void actionString() {
        String str = "shixinfa";
        char[] c = str.toCharArray();
        for (char data : c) {
            System.out.println(data);
        }
        String[] strdata = new String[] { "shixinfa" };
        boolean flag = strdata.equals(str);
        String s = new String("shixinfa");
        String s1 = new String("shixinfa");
        System.out.println(s == s1);
        System.out.println(s == str);
        System.out.println(s.equals(str));
    }

    // java类集
    public static void actionApi() {
        HashMap<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "北京大学");
        map.put(2, "清华大学");
        map.put(3, "浙江大学");
        while (!map.isEmpty()) {
            for (int i = 1; i <= 3; i++) {
                System.out.println(map.get(i));
            }
        }
        Collection<String> list = new ArrayList<String>();
        String[] s = { "shixinfa", "zhangyan", "yewen" };
        for (int i = 0; i < s.length; i++) {
            list.add(s[i]);
        }
        for (String str : list) {
            System.out.println(str);
        }
    }

    // 文件的操作
    public static void FileAction() throws IOException {
        File file = new File("c:\\sxf.txt");
        if (!file.exists()) {
            file.createNewFile();
            @SuppressWarnings("resource")
            FileWriter fileWriter = new FileWriter(file);
            fileWriter.write("shixinfa是个垃圾");
            @SuppressWarnings("unused")
            FileReader fileReader = new FileReader(file);
            StringBuffer sb = new StringBuffer();
            byte[] b = new byte[1024];
            while (fileReader.read() != -1) {
                sb.append(b);
            }
        }
    }

}

import java.util.ArrayList;
import java.util.HashMap;
public class Solution {
    //方法一
    public static int MoreThanHalfNum_Solution(int[] array) {
        int result = 0;
        if (array == null || array.length == 0) {
            return 0;
        }
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < array.length; i++) {
            if (map.get(array[i]) != null) {
                map.put(array[i], map.get(array[i]) + 1);
            } else {
                map.put(array[i], 1);
            }
            if (map.get(array[i]) > array.length / 2) {
                result = array[i];
            }
        }
        return result;
    }

    //方法二
    public static void HalfMore(int[] param) {
        int count = 0;
        //  int[] param = new int[]{2, 34, 345, 65, 64, 4};
        for (int i = 0; i < param.length - 1; i++) {
            for (int j = 0; j < param.length - 1 - i; j++) {
                if (param[j] > param[j + 1]) {
                    int temp = param[j];
                    param[j] = param[j + 1];
                    param[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < param.length - 1; i++) {
            if (param[i] == param[i + 1]) {
                count++;
            }
        }
        if (count >= param.length / 2) {
            System.out.println(param[param.length / 2]);
        }
    }


    //  最小的K个数
    public static ArrayList<Integer> getmin(int[] param, int k) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < param.length - 1; i++) {
            for (int j = 0; j < param.length - 1 - i; j++) {
                if (param[j] > param[j + 1]) {
                    int temp = param[j];
                    param[j] = param[j + 1];
                    param[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < k; i++) {
            list.add(param[i]);
        }
        return list;
    }

    //方法三 时间复杂度最小的方法
    public static void schemel(int[] ins, int k) {
        int[] ks = new int[k];
        //遍历K个数放入数组
        for (int i = 0; i < k; i++) {
            ks[i] = ins[i];
        }
        for (int i = k; i < ins.length; i++) {
            if (getMax(ks) > ins[i]) {
                ks[0] = ins[i];
            }
        }
        for (int i = 0; i < k; i++) {
            System.out.println(ks[i] + " ");
        }
    }

    public static int getMax(int[] ks) {
        int radix = 0;
        for (int i = 0; i < ks.length; i++) {
            if (ks[radix] < ks[i]) {
                int temp = ks[radix];
                ks[radix] = ks[i];
                ks[i] = temp;
            }
        }
        return ks[radix];
    }
    //子数组最大的和
    public static  int FindmaxSum(int[] array) {
        if (array.length == 0) {
            return 0;
        } else {
            int total = array[0], maxSum = array[0];
            for (int i = 1; i < array.length; i++) {
                if (total >= 0) {
                    total += array[i];
                } else {
                    total = array[i];
                }
                if (total > maxSum) {
                    maxSum = total;
                }
            }
            return maxSum;
        }
    }
    //第一个只出现一次的字符 ,youbug
    public static  int fitrstdiffappear(int[] shuzu){
        int result=0;
        for(int i=0;i<shuzu.length;i++) {
            for (int j = 0; j < shuzu.length; j++) {
                if (i != j && shuzu[i] == shuzu[j]) {
                    continue;
                }
            }
            result = shuzu[i];
        }
    return result;
    }
    
}

public class Test implements Runnable{
@Override
public synchronized void run() {
for (int i=0;i<100;i++){
System.out.println(i);
}
}
public static void main(String[] args) throws Exception{
Map<String,String> map=new HashMap<String,String>();
map.put("1","shixinfa");
map.put("2","shixiiaocun");
map.put("3","zhangyan");
for(String key:map.keySet()){
System.out.println(map.get(key));
}
for(String v:map.values()) {
System.out.println(v);
}
ArrayList<Integer> list=new ArrayList<Integer>();
list.add(22);
list.add(33);
list.add(44);
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
System.out.print("shixinfa");
String[] str={"shixinfa","shxinfa1","shixinfa2"};
for(String data:str){
System.out.println(data);
}
String strdata="zhang";
System.out.println(strdata.charAt(4));
System.out.println(strdata.length());
char[] c=strdata.toCharArray();
for(char data:c){
System.out.println(data);
}
StringBuffer sb=new StringBuffer(strdata);
char shuju= sb.charAt(2);
System.out.println(shuju);
File f=new File("E:\\sxf.txt");
//文件输入流
FileWriter fw = new FileWriter("E:\\sxf.txt",true);
fw.write("hello \r\nworld!");
fw.write("hahaha");
fw.close();
//文件输出流
FileReader fileReader=new FileReader(f);
char[] filedata=new char[50];
fileReader.read(filedata);//把数据读入数组中去
for(char cc:filedata){
System.out.println(cc);
fileReader.close();
}
//截取字符串的部分内容
String paramstr="shixinfa";
StringBuffer stringBuffer=new StringBuffer();
for(int start=3;start<6;start++){
stringBuffer.append(paramstr.charAt(start));
}
System.out.println(stringBuffer.toString());
//判断数组中是否包含某个数据
int[] param={22,342,345,6,7567,568};
int target=3545;
ArrayList<Integer> ls=new ArrayList<Integer>();
for(int data:param){
ls.add(data);
}
boolean flag= ls.contains(target);
System.out.println(flag);
//栈
Stack<Integer> stack=new Stack<Integer>();
stack.push(23);
stack.push(34);
stack.push(35);
stack.pop();
stack.pop();
for(int i=0;i<stack.size();i++){
System.out.println(stack.get(i));
}
//队列
Queue<Integer> queue=new PriorityQueue<Integer>();
queue.offer(23);
queue.offer(34);
queue.offer(45);
queue.peek();
for(int i=0;i< queue.size();i++){
System.out.println(queue.element());
}
//字符串的反转
String paramdata="shixinfa";
StringBuffer sbparamdata=new StringBuffer(paramdata);
String result=sbparamdata.reverse().toString();
System.out.println(result);
//字符串的反转
char[] chars=paramdata.toCharArray();
for(int i=0;i<chars.length/2;i++){
char sj=chars[i];
chars[i]=chars[chars.length-1-i];
chars[chars.length-1-i]=sj;
}
System.out.println(String.valueOf(chars));
//字符串的反转
char[] paramdatachar=paramdata.toCharArray();
Stack<Character> characterStack=new Stack<Character>();
Stack<Character> characterStacktarget=new Stack<Character>();
for(char pdc:characterStack) {
characterStack.push(pdc);
}
while(!characterStack.isEmpty()){
characterStacktarget.push(characterStack.pop());
}

for(int i=0;i<characterStacktarget.size();i++){
System.out.println(characterStacktarget.get(i));
}
//二分法查找
int[] canshu={3,43,56,66,77,89,676,678,889};
int canshuparam=89;
int start=0,end=canshu.length,middle=0;
while(start<=end) {
middle = (start + end) / 2;
if (canshu[middle] < canshuparam) {
start = middle + 1;
} else if (canshu[middle] > canshuparam) {
end = middle - 1;
} else {
System.out.println("这个数据是存在的");
}
}
Test testthread=new Test();
Thread thread=new Thread(testthread);
}
}package com.test;


import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;


import com.test.ThreadDemo.otherdemo;


public class SimpleDemo {
public static void sort(int[] a, int low, int high) {
int start = low;
int end = high;
int key = a[low];
while (end > start) {
// 从后往前比较
while (end > start && a[end] >= key) // 如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
end--;
if (a[end] <= key) {
int temp = a[end];
a[end] = a[start];
a[start] = temp;
}
// 从前往后比较
while (end > start && a[start] <= key)// 如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
start++;
if (a[start] >= key) {
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
// 此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
}
// 递归
if (start > low)
sort(a, low, start - 1);// 左边序列。第一个索引位置到关键值索引-1
if (end < high)
sort(a, end + 1, high);// 右边序列。从关键值索引+1到最后一个
}


public static void main(String[] args) throws IOException {
int[] a = { 3, 4, 566, 78, 54 };
for (int i = 0; i < a.length; i++) {
int min = i;
for (int j = i + 1; j < a.length; j++) {
if (a[i] > a[j]) {
min = j;
}
}
if (i != min) {
int tmp = a[min];
a[min] = a[i];
a[i] = tmp;
}
}
for (int l = 0; l < a.length; l++) {
System.out.println(a[l] + "\n");
}
for (int i = 0; i < a.length; i++) {
for (int j = i + 1; j < a.length; j++) {
if (a[j] > a[i]) {
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}


}
}
for (int k = 0; k < a.length; k++) {
System.out.print(a[k]);
}


ArrayList<String> list = new ArrayList<String>();
String[] s = { "shxiinfa", "zhangyan", "lixianglong" };
for (String i : s) {
list.add(i);
}


HashMap<String, String> map = new HashMap<String, String>();
map.put("name", "shxiinfa");
map.put("password", "940104");
// 遍历map的一种常见的方法
for (String key : map.keySet()) {
System.out.println(map.get(key));
}
Stack<Integer> stack = new Stack<Integer>();
for (int i = 0; i < 8; i++) {
stack.push(i);
}
Queue<Character> queue = new PriorityQueue<Character>();
queue.offer('a');
queue.offer('b');
queue.offer('c');
queue.peek();
for (Character c : queue) {
System.out.println(c);
}
int[][] b = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 8, 9, 0 } };
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < b[i].length; j++) {
System.out.println(b[i][j]);
}
}
String filepath = "c://sxf.txt";
File f = new File(filepath);
if (!f.exists()) {
f.createNewFile();
@SuppressWarnings("resource")
InputStream fileinput = new FileInputStream(f);
byte[] by = new byte[1024];
StringBuffer sb = new StringBuffer();
while (fileinput.read(by) != -1) {
sb.append(by);
}
}
Thread thread = new Thread();
thread.start();
thread.run();     
}
public class ThreadDemo implements Runnable {
 
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
}



static class otherdemo extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("励精图治");
}
}
}
   


public static void main(String[] args) {
otherdemo demo=new otherdemo();
demo.start();
ThreadDemo th = new ThreadDemo();
Thread thread = new Thread(th);
thread.start();
}
}
}
package com.test;


import java.util.SortedMap;


public class Test {
public static void main(String[] args) {
int[] a = { 2, 424, 54, 6, 88 };
int param = 67;
System.out.println(BinarySearch(a, param));
int[] result = SortMaopao(a);
for (int data : result) {
System.out.println(data);
}
int[] getdata = SelectSort(a);
for (int data : getdata) {
System.out.println(data);
}
int[] qiucksort = quickSort(a, 0, 4);
for (int qiuck : qiucksort) {
System.out.println(qiuck);
}


}


// 冒泡排序
public static int[] SortMaopao(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
for (int j = 0; j < a.length - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int temp;
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;


}
}
}


return a;
}


// 选择排序
public static int[] SelectSort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
int min = i;
for (int k = i + 1; k < a.length; k++) {
if (a[k] < a[i]) {
k = min;
}


if (i != k) {
int temp = a[i];
a[i] = a[k];
a[k] = temp;
}
}
}


return a;
}


// 二分法查找
public static boolean BinarySearch(int[] a, int param) {
int start = 0, end = a.length;
boolean flag = false;
while (end > start) {
int middle = (start + end) / 2;
if (a[middle] > param) {
end = middle - 1;
} else if (a[middle] < param) {
start = middle + 1;
}
if (a[middle] == param) {
flag = true;
}
}
return flag;
}


public static int getMiddle(int[] a, int low, int high) {
int tmp = a[low]; // 数组的第一个作为中轴
while (low < high) {
while (low < high && a[high] > tmp) {
high--;
}
a[low] = a[high]; // 比中轴小的记录移到低端
while (low < high && a[low] < tmp) {
low++;
}
a[high] = a[low]; // 比中轴大的记录移到高端
}
a[low] = tmp; // 中轴记录到尾
return low; // 返回中轴的位置
}


public static int[] quickSort(int[] a, int low, int high) {
if (low < high) {
int middle = getMiddle(a, low, high); // 将list数组进行一分为二
quickSort(a, low, middle - 1); // 对低字表进行递归排序
quickSort(a, middle + 1, high); // 对高字表进行递归排序
}
return a;
}


// 队列的插入和删除
public boolean isEmpty(Queue queue) {
if (queue.tail - queue.top == 0) {
return true;
}
return false;
}


// 判断队列是否已经满了
public boolean isFull(Queue queue) {
if (queue.tail == queue.queue.length)

{
return true;
}
return false;
}
   //在i位置插入数据
public void insert(Queue queue,int i,Queue data) {
queue.queue[i]=data;
queue.queue[queue.tail++]=queue.queue[queue.tail];


}
//在i位置删除数据
public void delete(Queue queue,int i) {
while(queue.tail>i) {
queue.queue[queue.tail--]=queue.queue[queue.tail];
}
//判断链表是否为空


}
}