java基础知识7

末蓝、 2022-03-07 08:50 224阅读 0赞

进程：一个正在运行的程序拥有该程序运行的所有资源，包括资源的分配和任务的调度。

线程：在进程中负责具体代码的执行，一个进程至少有一个线程

单线程:在整个程序中只有一个线程，这个线程为主线程

多线程：整个程序不止一个线程，除了主线程其它为子线程

并发：多个任务独立执行，一起执行

同步：同一时刻只能执行一个任务，该任务执行完成之后才能执行下一个任务

异步：一个线程中多个任务同时执行，一起执行

多线程：操作系统同时执行多个任务  
创建线程的方式：

1）继承Thread,重写run()方法

有开辟线程的能力，资源共享方面不是很方便。

2）实现runable接口，实现该接口的run()方法

没有开辟线程的能力，要将创建的对象交给指定线程来运行

线程池：

帮助我们管理线程，我们只需要将需要执行的任务交给线程池。

线程池会根据任务的个数，执行时长，将不同的任务交给线程池中的线程来执行。

线程死锁：

多个线程因为竞争资源而造成相互等待，若无外力作用这些进程都将无法向

防止线程死锁：

1）加锁顺序

2）加锁时限

3）加锁检验

线程锁：

当多个数据访问资源时，为了数据安全，保证当一个线程访问资源时，

其它线程不能访问。等上一个线程访问完成之后才能访问。

同步锁：

synchronized(对象){
        //同步代码块： 同一个对象锁下的所有线程，某个时间段内只能有一个线程在执行该代码块
         }

在同步代码块内：

wait():当前线程停止运行，被同一个线程锁的其它线程唤醒之后才能接着运行

wait(时长毫秒)：当前线程停止运行，当超过指定时长还没有被唤醒，就不等其它线程唤醒了，接着执行。

notify(): 唤醒同一个同步锁中某一个wait()锁

notifyAll(): 唤醒同一个同步锁中所有wait()线程

线程的生命周期：

创建（new）---就绪（start）---运行状态（等待CPU调用run方法，如果线程在运行时发生阻塞，

进入阻塞状态，之后又返回就绪状态，等待CPU的再次调用）---结束状态（run方法执行完成）

run和start方法的区别：

start:重新开启了一个线程，不必等待其它线程执行完成。

run:只是调应了一个普通方法，没有开启线程，程序还会按照顺序执行响应代码。

### 2.Hibernate为什么需要二级缓存？ ###

###    Mybatis如何开启二级缓存？ ###

###    Hibernate如何开开启二级缓存？ ###

2.1>Hibernate为什么需要需要二级缓存：

一级缓存是session级别的缓存，它属于事物级别的缓存，由hibernate管理，一般无需进行干涉。

二级缓存是SessionFactory级别的缓存，它是进程范围或群集范围的缓存。可以进行配置和更改，

并且可以动态进行加载和卸载。当一些数据不常发生变化或者允许偶尔的并发的时候，

二级缓存可能更有效率，因为它的缓存时间更久，不会像一级缓存一样一旦session销毁就销毁。

2.2>Mybatis开启二级缓存：

2.2.1>mybatis-config.xml

cacheEnabled介绍：

允许值：对在此配置文件下的所有cache进行全局性开/关设置

默认值：true

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70][]

2.2.2>在mapper.xml中开启二级缓存，mapper.xml下的sql执行完成会存储到它的缓存区

![20190511160141966.PNG][]

开启缓存后，第一次查询会执行sql,第二次及以后的查询都会在缓存中读取数据

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 1][]

注意：开启缓存的弊端是数据没有实时性，当数据库中的数据一旦修改，查询的数据还是缓存中的数据没有实时性，对于某些需要实时性显示数据的接口我们可以设置**useCache****="false"**,设置该属性后，该接口每次查询出来都是去执行sql查询出实时性数据。

相关配置说明：

①.设置useCache=false可以禁用当前select语句的二级缓存，

即每次查询都会发出sql去查询，默认情况是true，即该sql使用二级缓存。

总结：针对每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存。

![20190511161424365.PNG][]

②.清空缓存

总结：一般下执行完commit操作都需要刷新缓存，flushCache=true表示刷新缓存，这样可以避免数据库脏读。

![20190511161616758.PNG][]

注意：

（1）当为select语句时：

flushCache默认为false，表示任何时候语句被调用，都不会去清空本地缓存和二级缓存。

useCache默认为true，表示会将本条语句的结果进行二级缓存。

（2）当为insert、update、delete语句时：

flushCache默认为true，表示任何时候语句被调用，都会导致本地缓存和二级缓存被清空。

useCache属性在该情况下没有。

当为select语句的时候，如果没有去配置flushCache、useCache，那么默认是启用缓存的，

所以，如果有必要，那么就需要人工修改配置

2.2.3>对应的pojo实现序列化(implements Serializable)

2.2.4>**mybatis自身实现二级缓存弊端在于只能作用于数据库，**

**            此时需要我们引用第三方库作为缓存库，这样缓存更具有扩展性**

2.3>hibernate开启二级缓存

开启二级缓存需要导入三个jar包，还有一个配置文件到资源根目录下

![20190511174805928.png][]

ehcache.xml：

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"> 	
    	
    	<diskStore path="java.io.tmpdir" /> 
    	
     
    	<defaultCache maxElementsInMemory="1000"
    		maxElementsOnDisk="10000000" eternal="false" overflowToDisk="false"
    		timeToIdleSeconds="120" timeToLiveSeconds="120"
    		diskExpiryThreadIntervalSeconds="120" memoryStoreEvictionPolicy="LRU">
    	</defaultCache>
     
    	 
    	<cache name="userCache" maxElementsInMemory="3000" eternal="false"
    		overflowToDisk="true" timeToIdleSeconds="3600" timeToLiveSeconds="3600"
    		memoryStoreEvictionPolicy="LFU" />
     
    </ehcache>

hibernate.cfg.xml：

<property name="hibernate.cache.use_second_level_cache">true</property>	
    	     
    	 
    	  <property name="hibernate.cache.use_query_cache">true</property>
    	  
    	    
    	  
    	  <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
    	  
    	   
    	    <mapping resource="com/zhou/model/ClassRoom.hbm.xml"/>
    	    <mapping resource="com/zhou/model/Student.hbm.xml"/> 
    
            
          <class-cache usage="read-write" class="net.seehope.hibernate.pojo.Customer" />
          <class-cache usage="read-write" class="net.seehope.hibernate.pojo.Orders" />
            
          <collection-cache usage="read-write"   collection="net.seehope.hibernate.pojo.Customer.Orders"

注意：开启缓存要写在mapping映射下方

里面的集合缓存意思是缓存orders的id还是需要把Orders这个类也进行缓存

### 3.跨域？如何解决跨域问题？ ###

跨域：前端页面与后台运行在不同的服务器上

解决跨域问题：使用cors

特点：前端代码和未处理跨域前一样，即普通的ajax请求，

但服务器代码添加了一段解决跨域的代码

前端代码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 2][]

服务器代码

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 3][]

cors高级使用：在springmvc中配置拦截器

创建跨域拦截器实现HandlerInterceptor接口，并实现其方法，在请求处理前设置头信息，并放行  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 4][]

在springmvc的配置文件中配置拦截器，注意拦截的是所有的文件

![20190317174310289.PNG][]

### 4. 拦截器，过滤器，监听器的启动顺序？ 配置位置？ ###

###     spring监听器配置？ 设置处理字符编码的过滤器？ ###

###     配置拦截器？过滤器和拦截器的区别？ ###

启动顺序：

监听器 > 过滤器 > 拦截器

接到上级命令，要求对电话进去监听，过滤出恐怖分子，然后，拦截他们的恐怖袭击行动。

配置位置：

监听器，过滤器一般配置在web.xml中。

拦截器一般配置在springmvc.xml配置文件中

spring监听器的配置：在web.xml中

<listener>
       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

处理字符编码的过滤器：前端请求为post方式时，设置中文格式的过滤器，处理中文乱码格式

<filter>
      <filter-name>CharactorFilter</filter-name>    
      <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
      <init-param>   
    	<param-name>encoding</param-name>  
    	<param-value>utf-8</param-value>   
      </init-param>
      <init-param>
    	<param-name>forceEncoding</param-name>
    	<param-value>true</param-value>
      </init-param>
    </filter>
    <filter-mapping> 
        <filter-name>CharactorFilter</filter-name>
    	<url-pattern>/*</url-pattern>
    </filter-mapping>

配置拦截器：在springmvc.xml中

<mvc:interceptors>
      <mvc:interceptor>
         
         <mvc:mapping path="/managerLogin"/>
         
         <bean class="com.yangsheng.inteceptor.LoginInterceptor"></bean>
      </mvc:interceptor>
    </mvc:interceptors>

LoginInterceptor.java

public class LoginInterceptor implements HandlerInterceptor {
         /**
    	 * 调用handler之后执行
    	 */
          @Override
          public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            		throws Exception {
            	// TODO Auto-generated method stub
            	HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
            	
            	/**
        		 * 1.获得客户机信息
        		 */
        		String requestUrl = request.getRequestURL().toString();// 得到请求的URL地址
        		String requestUri = request.getRequestURI();// 得到请求的资源
        		String queryString = request.getQueryString();// 得到请求的URL地址中附带的参数
        		String remoteAddr = request.getRemoteAddr();// 得到来访者的IP地址
        		String remoteHost = request.getRemoteHost();
        		int remotePort = request.getRemotePort();
        		String remoteUser = request.getRemoteUser();
        		String method = request.getMethod();// 得到请求URL地址时使用的方法
        		String pathInfo = request.getPathInfo();
        		String localAddr = request.getLocalAddr();// 获取WEB服务器的IP地址
        		String localName = request.getLocalName();// 获取WEB服务器的主机名
        		String contextPath = request.getContextPath();
        		
        		System.out.println("请求的URL地址：" + requestUrl);
        		System.out.println("请求的资源：" + requestUri);
        		System.out.println("请求的URL地址中附带的参数：" + queryString);
        		System.out.println("来访者的IP地址：" + remoteAddr);
        		System.out.println("来访者的主机名：" + remoteHost);
    		    System.out.println("使用的端口号：" + remotePort);
    		    System.out.println("remoteUser：" + remoteUser);
        		System.out.println("请求使用的方法：" + method);
        		System.out.println("pathInfo：" + pathInfo);
        		System.out.println("localAddr：" + localAddr);
        		System.out.println("localName：" + localName);
        		System.out.println("contextPath:" + contextPath);
            }
         
         /**
    	 * 调用handler过程中执行
    	 */
    	@Override
    	public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,Object arg2, ModelAndView arg3)
    			throws Exception {
    	}
    	
    	/**
    	 * 在调用handler之前调用
    	 * true 不拦截;false 拦截
    	 */
    	@Override
    	public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1,Object arg2) throws Exception {
    		arg0.setCharacterEncoding("utf-8");
    		//如果用户没有登录则禁止访问，跳转到登录页面
    		if(arg0.getSession().getAttribute("user")==null){
    			arg0.getRequestDispatcher("login.jsp").forward(arg0, arg1);
    			return false;
    		}
    		   return true;
    	}
    
      }

过滤器和拦截器的区别：

1）Filter需要在web.xml中配置，依赖于servlet.

2)  Interceptor需要在springmvc中配置，依赖于框架

3）Filter的执行顺序在Intercetor之前。

4） Interceptor是基于java的反射机制的，而过滤器是基于函数回调的

5）从灵活性上说拦截器功能更强大些，Filter能做的事情，都能做，而且可以在请求前，请求后执行，比较灵活。Filter主要是针对URL地址做一个编码的事情、过滤掉没用的参数、安全校验（比较泛的，比如登录不登录之类）

6） Interceptor只能对action请求起作用，而过滤器可以对所有的请求起作用。

### 5.Mybatis多表联查 ###

5.1）一对多

一方表  
     多方表：多一个字段作为外键，此外键是和一方的主键关联  
     mybatis一方的配置文件resultMap中<collection property="集合的属性名" ofType="集合元素的类型"></collection>  
     多方的配置文件resultMap中<association property="一方的属性名" javaType="属性类型"></association>

5.2）多对多

多方表1  
    多方表2  
    中间表 ：其中一个字段为表1的外键，另一字段为表2的外键  
    在各自的resultMap中<collection></collection>

5.3）一对一

表1  
    表2： 在表2中增加一个字段是表1的外键，并且加唯一约束  
    在各自的resultMap中<association></association>

### 6.数组排序 ###

6.1）冒泡排序

/*
     * 外层for循环代表循环次数
     * 内层for循环对数字进行排序
     */
    
    	int[] sort(int[] array){
        	   if( array == null ){    //数组为空
        		   System.out.println("数组不能为null");
        		   return array;
        	   }
          if( array.length <= 1){  //数组的元素不大于1
        	      return array;
          }
        for(int i = 0; i < array.length-1; i++){
        	  for(int j = 0; j < array.length-1-i; j++){
        		  if(array[j] > array[j+1]){
        			  int temp = array[j];
        			  array[j] = array[j+1];
        			  array[j+1] = temp;
        		  }
        	  }
        }             
                   return array;
           }

6.2）自然排序

package java_排序和二分查找;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    
    public class Text_自然排序1 {
    
    	public static void main(String[] args) {
    		
    		   ArrayList<Girl> list = new ArrayList<>();
    			list.add(new Girl(25, "周帅", 174, 100));
    			list.add(new Girl(30, "张三", 178, 120));
    			list.add(new Girl(22, "李四", 163, 90));
    			list.add(new Girl(38, "毕燕", 165, 85));
      /*
       * sort括号里面使用匿名内部类，只要将if参数里面改动，
       * 就可以给4个随便哪个进行排序
       */
    	 Collections.sort(  list, new Comparator<Girl>() {
    
    		@Override
    		public int compare(Girl o1, Girl o2) {
    			if(o1.age > o2.age) {
    				return 1;
    			} else {
    				return -1;
    			}
    			
    		}
    	}  );
    	       for (Girl girl : list) {
    			System.out.println(girl);
    		}
    	
    	}
    }
    class Girl implements Comparable<Girl> {
          public  int age;
          public String name;
          public int height;
          public int score;     
    	
        public Girl(int age, String name, int height, int score) {	
    		this.age = age;
    		this.name = name;
    		this.height = height;
    		this.score = score;
    	}
          @Override
        public String toString() {
        	  String s1 = "name:" + name + " ";
        	  String s2 = "age:" + age + " ";
        	  String s3 = "height:" + height + " ";
        	  String s4 = "score:" + score  + " ";
         	return s1 + s2 + s3 + s4;
        }
    	@Override
    	public int compareTo(Girl o) {
    		// TODO Auto-generated method stub
    		return 0;
    	}
    	
    }

6.3）快排

package java_排序和二分查找;
    
    import java.util.Arrays;
    
    public class Text_快排 {
    
    	public static void main(String[] args) {
    		int[] array = { 10,30,15,12,56,9};
    		    sort(array, 0, array.length-1);
              System.out.println(Arrays.toString(array));
    	}
    	//快速排序
        public static void sort(int[] array, int begin, int end) {
        	   //当满足该条件,说明已经没有数字了或者只剩下一个数字了,没有必要再比较了
          	if (begin >= end) {
    			  return;
    		}
           //基准数
        	int key = array[begin];
        	//记录开始和结束位置
        	int start = begin;
        	 int over = end;
        	 /*
        	  * 从后面找到小的放到前面,
        	  * 从前面找到大的放到后面,
        	  * 当start 和 over 相遇,说明已经分区完成
        	  */
       while(start < over) {
        		 //从后面找到小的放到前面,当找到array[over] < key 小的停止
        		while(over > start && array[over] >= key) {
        			    over--;
        		 }
        		//将找到的比基准数(key)小的数字往前放
        		 array[start] = array[over];
        		//从前面开始,找到比基准数大的,往后放
        		while(over > start && array[start] <= key){
        			   start++;
        		}
        	 //找到前面比基准数大的,往后放
        		array[over] = array[start];
        	 }
        	 //将记录的基准数,放到相遇位置
        	    array[start] = key;
        	 //左区按照同样的原理,接着排序
        	    sort(array, begin, start-1);
        	  //右区
        	    sort(array, start+1, end);
        }
    }

6.4）选择排序

package java_排序和二分查找;
    
    import java.util.Arrays;
    
    public class Text_选择排序 {
    
    	public static void main(String[] args) {
    	/*
    	 * 选择排序:
    	 *   内层循环记录最小值的下标,
    	 *   将记录的最小值下标跟外层的i进行位置调换
    	 */
    		int[] array = { 50, 30, 20, 60, 15 };
    		for(int i = 0; i < array.length; i++){
    			   int index = i;  // index 记录最小值的下标
    		for(int j = i+1; j < array.length; j++){
    			if(array[index] > array[j]){
    				index = j;
    			}
    		}
    		 if( index != i ){
    			   int temp = array[index];
    			   array[index] = array[i];
    			   array[i] = temp;
    		 }			   
    		}
    	System.out.println(Arrays.toString(array));			
    	}
    }

6.5）冒泡和二分查找封装

package java_排序和二分查找;
    
    
    public class Text_冒泡和二分查找封装 {
    	
    	int[] sort(int[] array) {
    		if (array == null) { // 数组为空
    			System.out.println("数组不能为null");
    			return array;
    		}
    		if (array.length <= 1) { // 数组的元素不能小于1
    			return array;
    		}
    		for (int i = 0; i < array.length; i++) {
    			int index = i; // 记录最小值下标
    			for (int j = i + 1; j < array.length; j++) {
    				if (array[index] > array[i]) {
    					index = j;
    				}
    			}
    			if (index != i) {
    				int temp = array[index];
    				array[index] = array[i];
    				array[i] = temp;
    			}
    		}
    		return array;
    	}
    
    	int search(int[] a, int key) {
    		int[] sc = this.sort(a);
    		if (sc == null) {
    			System.out.println("数组不能为null");
    			return -1;
    		}
    		int index = -1;
    		int left = 0;
    		int right = sc.length - 1;
    		int middle = (left + right) / 2;
    		while (left <= right) {
    			middle = (left + right) / 2;
    			if (key == sc[middle]) {
    				index = middle;
    				break;
    			} else if (key > sc[middle]) {
    				left = middle + 1;
    			} else {
    				right = middle - 1;
    			}
    		}
    		if (index == -1) {
    			System.out.println("不存在");	
    			   return -1;
    		} else {		
    			System.out.println("在数组a的第" + (index + 1) + "位");
    			return index;
    		}
    	}
    }
    
    
    
    package java_排序和二分查找;
    
    public class Text_封装 {
    
    	public static void main(String[] args) {
    	   
             Text_冒泡和二分查找封装  sc = new Text_冒泡和二分查找封装();
                int[] a = new int[]{ 20, 50, 60, 10, 100 };
                      sc.sort(a);
                 for(int temp : a){
            	    System.out.print(temp + " ");
                  }
    	             System.out.println();
    	     Text_冒泡和二分查找封装  sv = new Text_冒泡和二分查找封装();
    	        sv.search( a, 50);
    	}
    }

6.6）插入排序

package java_排序和二分查找;
    
    import java.util.Arrays;
    
    public class Text_插入排序 {
    
    	public static void main(String[] args) {
    		/*
    		  * 定义一个整形数组，里面有10个元素，
    		  * 对数组进行升序排列
    		  * 然后使用二分法查找找数组中是否有2这个元素	
    		  */
    		int[]array={10,8,9,50,101,102};
    		/* 假设第一个元素为有序数据
    		 * 无序的数据：有length-1个数字 
    		 */
    	for(int i=1;i<array.length;i++){
    		/* i就是从无序的数据中拿出的数字下标
    		 所以[0，i-1]是有序数据
    		 用下标为i的和i-1比较，如果比i-1小再和i-2比较
    		  直到某个数字比i下标的数字还小为止。
    		 从找到的位置到i-1、集体往后移动一位数字，
    		 为目前i下标数字留出位置*/
    		//将要确定的数字先保存起来
    		int temp=array[i];
    		//记录最终数字的位置
    		int index=0;
    		//和有序数字进行比较,从大数到小数比较
    		for(int j=i-1;j>=0;j--){
    			//要确定位置的数字找比有序数据中比他还小的数字
    			if(array[i]>array[j]){
    				index=j+1;
    				break;
    			}
    		}
    	/*
    	 * 挪位置 找到位置为 index 要确定的数字的位置i
    	 * 从index到i-1统统往后挪一位
    	 */
    	for(int k = i-1; k >= index; k--){
    		array[k+1] = array[k];
    	}
    	//将temp值插入到index的位置
    	array[index] = temp;
    	}
    	System.out.println(Arrays.toString(array));	
    	}
    }

6.7）二分插入排序

package java_排序和二分查找;
    
    import java.util.Arrays;
    
    public class Text_二分插入排序 {
    
    	public static void main(String[] args) {
       
       int[] array = {10,8,12,4,3};
       /*
        * 第一轮：i = 1
        * 初始：left 0  right 0  mid 0
        * 结束：left 0  right -1
        * 8 10 12 4 3
        * 第二轮: i = 2
        * 初始：left 0  right 0  mid 0
        * while执行一次：left 1  right 1  mid 1;
        * while执行二次：left 2  right 2
        * 8 10 12 4 3
        *    
        */
       //一共有多少数字要确定位置
       for (int i = 1; i < array.length; i++) { 
    		//需要确定位置的数字
    	    int temp = array[i];
    	   //左边界初始化为0;
    	    int left = 0;
    		/*
    		 * 有序数列的右边界，要确定位置的数字
    		 * 之前都是有序的，右边界就是i-1
    		 */
    	    int right = i-1;
    		int mid = (left + right) / 2;
    		while(left <= right) {
    			mid = (left + right) / 2;
    		    if (array[mid] > temp) {
    		//说明有序数列中中间数字比要确定位置的数字大		
    		    	  right = mid - 1;
    			} else {
    				left = mid + 1;
    			}
    		} 
    		//要确定位置的数字挪出位置
    	      for (int j = i-1; j >= left; j--) {
    			    array[j+1] = array[j];			 
    		}  
    	            array[left] = temp; 
       }	
    	  System.out.println(Arrays.toString(array));
    	 	
    	   }
    	}

### 7.java字符串 ###

7.1）字符串出现次数

package java_字符串;
    
    import java.util.HashMap;
    import java.util.Scanner;
    
    public class Text_字符出现次数 {
    
    	public static void main(String[] args) {
     // 从控制台输入字符串，统计每个字符出现的次数	 
    	Scanner scanner = new Scanner(System.in);
    	 System.out.println("请输入字符串");
         String sc = scanner.next();
     // 创建map,将字符作为键，出现的次数作为值   
        HashMap<Character , Integer> map = new HashMap<>();
         for (int i = 0; i < sc.length(); i++) {
    		 char ch = sc.charAt(i);
    		    /*
    			 * 如果是首次出现直接添加键值对
    			 * 如果不是，在原有的基础上+1
    			 */
    		 // 不包含，第一次出现
    	     if (!map.containsKey(ch)) {
    			  map.put(ch, 1);
    		} else {
    		 // 不是第一次出现	
    			map.put(ch, map.get(ch) + 1);
    		} 
         }
    	for (Character key : map.keySet()) {
    		System.out.println(key + "(" + map.get(key) + ")");
    	}
    		
    	}
    }

7.2）统计小写字母，大写字母，数字出现次数

package java_字符串;
    
    import java.util.Scanner;
    
    public class Text_出现次数 {
    
    	public static void main(String[] args) {
    /*
     * 	控制台输入一段字符串，统计其中小写字母、
     * 大写字母、数字出现的的次数，例如：输入 abc123AVC
        输出:小写字母:3次  大写字母:3次  数字:3次	
     */
       Scanner scanner = new Scanner(System.in);
    	  System.out.println("请输入");
    	String string = scanner.next();
      //  字符数组不用加括号，字符串需要加括号	
    	int[] count = new int[3];
    	for(int i = 0; i < string.length(); i++){
    		char c = string.charAt(i);
    	  if( c >= 97 && c <= 122 ){
    		  count[0]++; // 小写		  
    	  }else if( c >= 65 && c <= 90 ){
    		  count[1]++;  // 大写
    	  } else if ( c >= 48 && c <= 57 ) {
    		  count[2]++; // 数字
    	  }	
    	}
    System.out.println("小写字母:" + count[0] + "次"  + " " 
    	+ "大写字母:" + count[1] + "次" + " "
    	+ "数字" + count[2] + "次" );	
    	
    	 }		
    	}

7.3）反转

package java_字符串;
    
    public class Text_反转 {
    
    	public static void main(String[] args) {
    		/*
    		 * 编写程序将"test."变为"tset."
    		 */
    //    StringBuffer buffer = new StringBuffer("test");
    //    System.out.println(buffer.reverse());
    	
    	/*
    	 * 编写程序，将"To be or not to be" 变为
    	 *   "oT eb ro ton ot eb" 每个单词都反转。
    	 */	
    	String str = "To be or not to be";
    	String[] s1 = str.split(" "); //切割为字符串数组
    	 String result = "";   //遍历数组为每个元素反转
    	for(String item : s1 ){
    	  StringBuilder sc = new StringBuilder(item);
    	  StringBuilder sb = sc.reverse();  //反转	   
    	  String s2 = sb.toString();
    	   result = result + s2 + " ";
    	}
    	System.out.println(result);
    	
    	}
    }

7.4）去重复的字母

public class Text_去重复字母 {
    
    	public static void main(String[] args) {
     /*
      * 从控制台输入任意字母，将其中重复出现的字母去掉
      */
    	 Scanner scanner = new Scanner(System.in);
    	    System.out.println("请输入字母");
    	    String sc = scanner.next();
    	   String  result = "";
    	   for(int i = 0; i < sc.length(); i++){
    		   char c = sc.charAt(i);
    		   int index = result.indexOf(c); //判断里面是否有需要字母
    		 if(index == -1){
    			 result = result + c;
    		 }
    		    
    	   }
    	   System.out.println(result); 
      }

7.5）首字母大写

public class Text_首字母大写 {
    
    	public static void main(String[] args) {
          String string = "to be or not to be";
            // 切割为字符串数组
    	  String[] str = string.split(" ");   //忘记[]
    	    String result = "";
    	  for(String item : str){
    		 char first = item.charAt(0);
    		     char sc = first;  // 小写转大写
    		 if(first >= 97 && first <= 122){
    			    sc = (char)( first -32 );
    		 }
    	  //  String 转化为StringBuider
    	   StringBuilder  ss = new StringBuilder(item);
    	  // 替换为大写          字符转化为字符串
    	    ss.replace(0, 1, Character.toString(sc));	    	 
    	   // 将StringBuider 转化为String 
    	       item = ss.toString();    // 不要忘记转回来
    	    result = result + item + " ";
    	 }
    		System.out.println(result);	
    	}
    }

7.6）小写转大写

public class Text_小写转大写 {
    
    	public static void main(String[] args) {
         String string = "jdk";
    	 String string2 = "";
    	 for(int i = 0; i < string.length(); i++){
    		char c = string.charAt(i); //得到原有字符
    		char sc = c; //判断字符是否为小写，转换为大写
    		if( 97 <= c && c <= 122 ){
    			sc = (char)( c - 32 );
    			string2 += sc;  // 将得到大写的字符拼接
    		}
    	}
    		System.out.println(string2);
    	}
    }

7.7）Text练习

package java_字符串;
    
    import java.awt.event.MouseWheelEvent;
    import java.security.acl.Permission;
    import java.text.AttributedString;
    
    import javax.swing.plaf.synth.SynthToggleButtonUI;
    
    import org.omg.CORBA.PUBLIC_MEMBER;
    import org.omg.CORBA.portable.ValueBase;
    /*
      * 一个源文件里面只能有一个被public修饰的类，
      * 被public修饰的方法可以有多个
      */
    import org.omg.Messaging.SyncScopeHelper;
    public class Text {
    
    	public static void main(String[] args) {	
          Person person = new Person();
             person.name = "周帅";
             person.age = 30;     
          System.out.println(person.toString());
          	
    	/*
    	 * 	1.编写程序将"jdk"全部变为大写，输出；截取子串"DK" 并输出
    	 */
    //  方法一：
    	    String string = "jdk";
    	    String string2 = string.toUpperCase();
    		System.out.println(string2);	 
     //方法二：
    //	     String string = "jdk";
    //	       String str = "";
    //	for(int i =0; i < string.length(); i++){
    //	  // 得到原有的字符
    //		char c = string.charAt(i);
    //	  // 先判断是否都是小写
    //	    char bc = c;
    //	    //将字符变为大写  ASCII码表  小写(97-122)  大写(65-90)
    //	    if( 97 <= c && c <= 122 ){
    //	    	    bc = (char)( c - 32 );  
    //	    }		
    //	//  将转换好的字符拼接
    //		str += bc;	
    //	}
    //	   System.out.println(str);			
    //		 String n = string2.substring(1);
    //		 System.out.println(n);
    
    	/*
    	 * 2.编写程序将"test"变为"tset"
    	 */
    		StringBuffer sb = new StringBuffer("test");
    		System.out.println(sb.reverse());
    		
    	/*
    	 * 3.编写程序将"test."变为"tset."	
    	 */    
    //	 	String string = "test.";
    //	 	string.toCharArray();
    //	 	char[] ch =string.toCharArray();
    //	 	char temp = ch[1];
    //	 	  ch[1] = ch[2];
    //	 	  ch[2] = temp;
    //	   String result = new String(ch);
    //	   System.out.println(result); 	
    	
    	 /*
    	  * 5.编写程序，将"To be or not to be" 变为
    	  *  "oT eb ro ton ot eb" 每个单词都反转。
    	  */	
        // 每个单词反转
    		String string = "To be or not to be";
    	//切割为字符串数组
    	 String[] s1 = string.split(" ");
    	 //遍历数组，将每个元素反转
    	  String result = "";
    	for(String item : s1) {
    		StringBuilder ss = new StringBuilder(item);
    		StringBuilder sv = ss.reverse();
    		String s2 = sv.toString();
    		   result = result + s2 + " ";
    	}
    	 System.out.println(result);
    		
    	/*
    	 * 将每个单词的首字母大写	
    	 */ 
    	// 每个单词反转
    			String string = "To be or not to be";
    		//切割为字符串数组
    		 String[] strArray = string.split(" ");
    		 //遍历数组，将每个元素反转
    		  String result = "";
      for(String item: strArray){        //获取子字符串    大小写转化                  
    			 String upFirst =  item.substring(0, 1).toUpperCase();
    		     StringBuilder bf = new StringBuilder(item);  
    		     bf.replace(0, 1, upFirst);
    		     item = bf.toString();
    		     result = result + item + " ";
    		   }
    		System.out.println(result);	
     for (String item: strArray){
    		//得到首字母大写
    		char first = item.charAt(0);
    		      char bf = first;
    		if(first >= 97 && first <= 122){
    		    bf = (char)(first - 32);
    	    // 用大写替换小写
    		}
    		 StringBuilder b = new StringBuilder(item);
    	     b.replace(0, 1, Character.toString(bf));  
    		        //Character.toString(bf) 字符转换成字符串	
    		item = b.toString();
    	 result = result + item + " " ; 
    	}	
    	System.out.println(result);
    		
    	/*
    	 * 6.从控制台输入任意小写字母，将其中重复的出现的字母去掉。
    	 */
    	// 去重
    		String str = "1123王yyTTToO";
    	//接受结果
    	 String result = "";
    	 for(int i = 0; i < str.length(); i++){
    		char c = str.charAt(i) ;
    		int index = result.indexOf(c);  // 判断里面是否有需要字符
    		if( index == -1 ){
    			result = result + c;
    		}
    	 }
    	 System.out.println(result);
    	
    	/*
    	 * 7.从控制台输入一段字符串，统计其中小写字母、
    	 * 大写字母、数字出现的的次数，例如：输入 abc123AVC
           输出:小写字母:3次  大写字母:3次  数字:3次
    
    	 */
    	String string = "123yyYY";
    	int[] count = new int[3];
    	for(int i = 0; i < string.length(); i++){
    		char c = string .charAt(i);
    	  if(c >= 97 && c <= 122){
    		  count[0]++;  //小写
    	  }else if( c >= 65 && c <= 90){    //大写
    		  count[1]++;
    	  }else if( c >= 48 && c <= 57){    // 数字
    		  count[2]++;
    	  }
    	}
    	System.out.println("小写"+ count[0] + "大写" + count[1] + "数字"+ count[2]);
    
    
    字符串转换为字符数组
    //public static char[]toCharArray(String str){
    //	// 非null判断
    //if ( str == null ) {
    //	      System.out.println("字符");
    //	       return null;
    //}
     创建字符数组
    //char[] charArray = new char[str.length()];
    ///*
    // * 遍历字符串，
    // * 将每个字符放到字符数组中
    // */
    //for( int i = 0; i < str.length(); i++ ){
    //	 char c = str.charAt(i);
    //	 charArray[i] = c;
    //}
    //   return charArray;
    //}
    //	}
       
    	}
    }
    
    class Person {
    	 String name;
    	 int age;	 
    	 @Override
    	public String toString() {	
    		String result = "name:"+ name + " " + "age:" + age;
    		 return result;
    	}
     }

### 8.字符串拼接，得到字符串的长度，得到字符串中的某个字符， ###

###    根据字符获取下标，查找子字符串，获取子字符串， ###

###    判断字符串的开头/结尾，大小写转换，字符串切割 ###

###     将字符那串转化为字符数组 ###

public class StringClass {
    
    	public static void main(String[] args) {
         
            /*
    		 * 字符串：== 比较的是内存地址 equals方法比较的是值      
    		 */
    		      
    		/*
    		 * <1>字符串拼接
    		 */
    		/*
    		 * String 不可变字符串
    		 * 当字符串的内容发生了改变，就会产生新的字符串
    		 */
    		String a = "ab";
    		//参数只能是字符串
    		a = a.concat("cde")	; //String b = a.concat("cde") ;
    		a = a + (12 + 0.5);
    		System.out.println(a);
    		
    		/*
    		 * <2>得到字符串的长度(字符个数)      
    		 */
    		 String l = "程刚是个帅哥";
    		 System.out.println(l.length());
    		 
    		 /*
    		  * <3>得到字符串中的某个字符
    		  */
    		 //参数从0开始，到length-1;
    		 // 打印时，字符串要加括号，数组不要加。
    		for (int i = 0; i < l.length(); i++){
    		         char c = l.charAt(i);
    			System.out.print(c);	
    			} 
    		  System.out.println();
    		  
          /* 
           * <4> 根据字符获得下标,
           *  如果方法的返回值为-1，说明没有找到从左开始找，找到第一个结束
           */	
    		String str = "aabcde";
    	  int index =str.indexOf('a');  // 左往右找	
        //int index = str.lastIndexOf('a'); //右往左找
    	   System.out.println(index);
    	
    	/*
    	 *<5>查找子字符串，
    	 *返回的值为子串中第一个字符的位置将子串看作一个整体 	 
    	 */
           int index = str.indexOf("bcd");
           System.out.println(index);
    	 /*
    	  * 第一个参数：要查找的字符或者字符串
    	  * 第二个参数：查找的起始位置
    	  */	
    		int index = str.indexOf('a', 1);
    		System.out.println(index);
    		
    	//<6>获取子字符串
        	String str = "abcde";
    	 /*
    	  *（1） 第一个参数是起始的下标（包含）
    	  * 第二个参数是结束的下标（不包含）
    	  */
    	   String sub = str.substring(1, 3);
    	//（2）从给定位置截取到最后
         	String  sub = str.substring(1);
    	    System.out.println(sub);
    		
      //<7>判断字符串的开头
         String url = "http://www.lanou3g.com";
         boolean start =	url.startsWith("dfdd");
           System.out.println(start);
        
      //<8>判断字符串的结尾
         boolean end = url.endsWith("com");
    	   System.out.println(end);
    	
      //<9>大小写转换
    	    String string = "ZHUJGJ";
            string = string.toUpperCase();
    	    System.out.println(string);
        //将大写转换为小写
    	  String low = string.toLowerCase(); 
    	   System.out.println(low);
    	
      //<10>字符串切割
    	 String ss  = "雨桐,宾格,杨洋,乐乐"; 
    	 String[] names = ss.split(",");//参数：按照那个标准切割
    	 System.out.println(Arrays.toString(names));
    	 
     //<11>将字符串转换为字符数组
    	String tt = "我是最棒的";
    	char[] charArray = tt.toCharArray();
    	    System.out.println(charArray);
    	
    	char[] arr = new char[tt.length()];	 
    	for(int i = 0; i < tt.length(); i++) {
    		 arr[i] = tt.charAt(i);
    	 System.out.print(arr[i]);
    	 } 
     }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70]: /images/20220307/531a240c17824b519fb0180863ab737d.png
[20190511160141966.PNG]: /images/20220307/7860f6ec42884e329332be4a5c044251.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 1]: /images/20220307/785720ee5393406a94364aa4c5fe4895.png
[20190511161424365.PNG]: /images/20220307/57bf1d552823418f8b46016c113e1dff.png
[20190511161616758.PNG]: /images/20220307/6e38e966c6864eaa80bff9c3fd946c91.png
[20190511174805928.png]: /images/20220307/0787154a62dd4ef0a3921f7db2a4f4fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 2]: /images/20220307/0fff8fa5761d48eaacf36c49ea6c383c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 3]: /images/20220307/e2506d3ef6bc45c89321c54af7394a9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 4]: /images/20220307/8272e43bb08c493792e0e6314282cb13.png
[20190317174310289.PNG]: /images/20220307/d61c83244584447c8b4a8c6bd514d92d.png