首页 文章 精选 留言 我的

Android笔记：bitmap转换与处理相关工具类,Bitmap与DrawAble与byte[]与InputStream之间的转换

2017-11-28 705

1.将view转为bitmap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 将view转为bitmap
public  static  Bitmap getBitmapFromView(View view)
{
     // Define a bitmap with the same size as the view
     Bitmap returnedBitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.ARGB_8888);
     // Bind a canvas to it
     Canvas canvas =  new  Canvas(returnedBitmap);
     // Get the view's background
     Drawable bgDrawable = view.getBackground();
     if  (bgDrawable !=  null )
         // has background drawable, then draw it on the canvas
         bgDrawable.draw(canvas);
     else
         // does not have background drawable, then draw white background on
         // the canvas
         canvas.drawColor(Color.WHITE);
     // draw the view on the canvas
     view.draw(canvas);
     // return the bitmap
     return  returnedBitmap;
}



2.将view转为bitmap

1
2
3
4
5
6
7
8
// 将view转为bitmap
public  static  Bitmap viewToBitmap(View view)
{
     view.setDrawingCacheEnabled( true );
     view.buildDrawingCache();
     Bitmap bm = view.getDrawingCache();
     return  bm;
}




3.将xml转为bitmap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 将xml转为bitmap
public  static  Bitmap convertBitmapFromXML(Context context, String clusterSize, Bitmap bm)
{
                                                                                                                                                                                                                                                                                                                                                                                        
     View layout = LayoutInflater.from(context).inflate(R.layout.estatecartlist_item,  null );
     View bitmapView = layout.findViewById(R.id.estatecartlist_item_bitmap);
     TextView xml_text = (TextView) layout.findViewById(R.id.item_estatecart_tv_name);
     ImageView image = (ImageView) layout.findViewById(R.id.item_estatecart_iv_main);
     image.setImageBitmap(bm);
     xml_text.setText(clusterSize);
                                                                                                                                                                                                                                                                                                                                                                                        
     bitmapView.measure(MeasureSpec.makeMeasureSpec( 0 , MeasureSpec.UNSPECIFIED), MeasureSpec.makeMeasureSpec( 0 , MeasureSpec.UNSPECIFIED));
                                                                                                                                                                                                                                                                                                                                                                                        
     bitmapView.layout( 0 ,  0 , bitmapView.getMeasuredWidth(), bitmapView.getMeasuredHeight());
                                                                                                                                                                                                                                                                                                                                                                                        
     final  Bitmap clusterBitmap = Bitmap.createBitmap(bitmapView.getMeasuredWidth(), bitmapView.getMeasuredHeight(), Bitmap.Config.ARGB_8888);
                                                                                                                                                                                                                                                                                                                                                                                        
     Canvas canvas =  new  Canvas(clusterBitmap);
     bitmapView.draw(canvas);
     return  clusterBitmap;
}



==============参考资料===================

* 1.http://stackoverflow.com/questions/7200535/how-to-convert-views-to-bitmap

* 2.http://stackoverflow.com/questions/5536066/convert-view-to-bitmap-on-android/9595919#9595919

* 3.http://stackoverflow.com/questions/12402392/android-converting-xml-view-to-bitmap-without-showing-it






4.图片缩放与压缩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
// 按大小缩放
private  Bitmap getimage(String srcPath)
{
     BitmapFactory.Options newOpts =  new  BitmapFactory.Options();
     // 开始读入图片，此时把options.inJustDecodeBounds 设回true了
     newOpts.inJustDecodeBounds =  true ;
     Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts); // 此时返回bm为空
                                                                                                                                                                                                                                                                                                                                                                               
     newOpts.inJustDecodeBounds =  false ;
     int  w = newOpts.outWidth;
     int  h = newOpts.outHeight;
     // 现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
     float  hh = 800f; // 这里设置高度为800f
     float  ww = 480f; // 这里设置宽度为480f
     // 缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
     int  be =  1 ; // be=1表示不缩放
     if  (w > h && w > ww)
     { // 如果宽度大的话根据宽度固定大小缩放
         be = ( int ) (newOpts.outWidth / ww);
     }
     else  if  (w < h && h > hh)
     { // 如果高度高的话根据宽度固定大小缩放
         be = ( int ) (newOpts.outHeight / hh);
     }
     if  (be <=  0 )
         be =  1 ;
     newOpts.inSampleSize = be; // 设置缩放比例
     // 重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
     bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
     return  compressImage(bitmap); // 压缩好比例大小后再进行质量压缩
}
// 图片质量压缩
private  static  Bitmap compressImage(Bitmap image)
{
     ByteArrayOutputStream baos =  new  ByteArrayOutputStream();
     image.compress(Bitmap.CompressFormat.JPEG,  100 , baos); // 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
     int  options =  100 ;
     while  (baos.toByteArray().length /  1024  >  100 )
     {  // 循环判断如果压缩后图片是否大于100kb,大于继续压缩
         baos.reset(); // 重置baos即清空baos
         image.compress(Bitmap.CompressFormat.JPEG, options, baos); // 这里压缩options%，把压缩后的数据存放到baos中
         options -=  10 ; // 每次都减少10
     }
     ByteArrayInputStream isBm =  new  ByteArrayInputStream(baos.toByteArray()); // 把压缩后的数据baos存放到ByteArrayInputStream中
     Bitmap bitmap = BitmapFactory.decodeStream(isBm,  null ,  null ); // 把ByteArrayInputStream数据生成图片
     return  bitmap;
}
// 图片按比例大小压缩
private  static  Bitmap comp(Bitmap image)
{
                                                                                                                                                                                                                                                                                                                                                                               
     ByteArrayOutputStream baos =  new  ByteArrayOutputStream();
     image.compress(Bitmap.CompressFormat.JPEG,  100 , baos);
     if  (baos.toByteArray().length /  1024  >  1024 )
     { // 判断如果图片大于1M,进行压缩避免在生成图片（BitmapFactory.decodeStream）时溢出
         baos.reset(); // 重置baos即清空baos
         image.compress(Bitmap.CompressFormat.JPEG,  50 , baos); // 这里压缩50%，把压缩后的数据存放到baos中
     }
     ByteArrayInputStream isBm =  new  ByteArrayInputStream(baos.toByteArray());
     BitmapFactory.Options newOpts =  new  BitmapFactory.Options();
     // 开始读入图片，此时把options.inJustDecodeBounds 设回true了
     newOpts.inJustDecodeBounds =  true ;
     Bitmap bitmap = BitmapFactory.decodeStream(isBm,  null , newOpts);
     newOpts.inJustDecodeBounds =  false ;
     int  w = newOpts.outWidth;
     int  h = newOpts.outHeight;
     // 现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
     float  hh = 800f; // 这里设置高度为800f
     float  ww = 480f; // 这里设置宽度为480f
     // 缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
     int  be =  1 ; // be=1表示不缩放
     if  (w > h && w > ww)
     { // 如果宽度大的话根据宽度固定大小缩放
         be = ( int ) (newOpts.outWidth / ww);
     }
     else  if  (w < h && h > hh)
     { // 如果高度高的话根据宽度固定大小缩放
         be = ( int ) (newOpts.outHeight / hh);
     }
     if  (be <=  0 )
         be =  1 ;
     newOpts.inSampleSize = be; // 设置缩放比例
     // 重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
     isBm =  new  ByteArrayInputStream(baos.toByteArray());
     bitmap = BitmapFactory.decodeStream(isBm,  null , newOpts);
     return  compressImage(bitmap); // 压缩好比例大小后再进行质量压缩
}




5.图片转为文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 图片转为文件
public  static  boolean  saveBitmap2file(Bitmap bmp, String filename)
{
     CompressFormat format = Bitmap.CompressFormat.JPEG;
     int  quality =  100 ;
     OutputStream stream =  null ;
     try
     {
         stream =  new  FileOutputStream( "/sdcard/"  + filename);
     }
     catch  (FileNotFoundException e)
     {
         e.printStackTrace();
     }
                                                                                                                                                                                                                                                                                                                                                                      
     return  bmp.compress(format, quality, stream);
}



6.屏幕截屏方法

1
2
3
4
5
6
7
8
9
// 屏幕截屏方法 获取当前屏幕bitmap,转换成bytes[] 调用 UI分享方法
public  void  printscreen_share(View v)
{
     View view1 = getWindow().getDecorView();
     Display display = getWindowManager().getDefaultDisplay();
     view1.layout( 0 ,  0 , display.getWidth(), display.getHeight());
     view1.setDrawingCacheEnabled( true );
     Bitmap bitmap = Bitmap.createBitmap(view1.getDrawingCache());
}



7.把Bitmap 转成 Byte

1
2
3
4
5
6
7
// 把Bitmap 转成 Byte
public  static  byte [] Bitmap2Bytes(Bitmap bm)
{
     ByteArrayOutputStream baos =  new  ByteArrayOutputStream();
     bm.compress(Bitmap.CompressFormat.PNG,  100 , baos);
     return  baos.toByteArray();
}


8.图片转为文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// 图片转为文件
public  static  boolean  saveBitmap2file(Bitmap bmp)
{
     CompressFormat format = Bitmap.CompressFormat.PNG;
     int  quality =  100 ;
     OutputStream stream =  null ;
     try
     {
         // 判断SDcard状态
         if  (!Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()))
         {
             // 错误提示
             return  false ;
         }
                                                                                                                                                                                                                                                                                                        
         // 检查SDcard空间
         File SDCardRoot = Environment.getExternalStorageDirectory();
         if  (SDCardRoot.getFreeSpace() <  10000 )
         {
             // 弹出对话框提示用户空间不够
             Log.e( "Utils" ,  "存储空间不够" );
             return  false ;
         }
                                                                                                                                                                                                                                                                                                        
         // 在SDcard创建文件夹及文件
         File bitmapFile =  new  File(SDCardRoot.getPath() + FILE_PATH);
         bitmapFile.getParentFile().mkdirs(); // 创建文件夹
         stream =  new  FileOutputStream(SDCardRoot.getPath() + FILE_PATH); // "/sdcard/"
     }
     catch  (FileNotFoundException e)
     {
         e.printStackTrace();
     }
     return  bmp.compress(format, quality, stream);
}



9.下载图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// 下载图片
public  static  Bitmap loadImage(String... params)
{
     InputStream is =  null ;
     Bitmap bitmap =  null ;
     try
     {
         URL url =  new  URL(params[ 0 ]);
         HttpURLConnection conn = (HttpURLConnection) url.openConnection();
         conn.setReadTimeout( 5000 );
         conn.setConnectTimeout( 5000 );
         if  (HttpURLConnection.HTTP_OK != conn.getResponseCode())
         {
             // 网络连接异常
             Log.e( "" ,  "loadImage连接异常" );
             return  null ;
         }
                                                                                                                                                                                                                                                                           
         is = conn.getInputStream();
         bitmap = BitmapFactory.decodeStream(is);
                                                                                                                                                                                                                                                                           
     }
     catch  (MalformedURLException e)
     {
         e.printStackTrace();
     }
     catch  (IOException e)
     {
         e.printStackTrace();
     }
     finally
     {
         if  ( null  != is)
         {
             try
             {
                 is.close();
             }
             catch  (IOException e)
             {
                 e.printStackTrace();
             }
         }
     }
     return  bitmap;
}


10.byte[]转换成Bitmap

1
2
3
4
5
6
7
8
9
// byte[]转换成Bitmap
public  static  Bitmap Bytes2Bitmap( byte [] b)
{
     if  (b.length !=  0 )
     {
         return  BitmapFactory.decodeByteArray(b,  0 , b.length);
     }
     return  null ;
}


11.将字符串转换成Bitmap类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public  static  Bitmap stringtoBitmap(String string)
{
     // 将字符串转换成Bitmap类型
     Bitmap bitmap =  null ;
     try
     {
         byte [] bitmapArray;
         bitmapArray = Base64.decode(string, Base64.DEFAULT);
         bitmap = BitmapFactory.decodeByteArray(bitmapArray,  0 , bitmapArray.length);
     }
     catch  (Exception e)
     {
         e.printStackTrace();
     }
                                                                                                                                                                                                                                             
     return  bitmap;
}



12.将Bitmap转换成字符串

1
2
3
4
5
6
7
8
9
10
public  static  String bitmaptoString(Bitmap bitmap)
{
     // 将Bitmap转换成字符串
     String string =  null ;
     ByteArrayOutputStream bStream =  new  ByteArrayOutputStream();
     bitmap.compress(CompressFormat.PNG,  100 , bStream);
     byte [] bytes = bStream.toByteArray();
     string = Base64.encodeToString(bytes, Base64.DEFAULT);
     return  string;
}




13.byte[]转为文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
//byte[]转为文件
public  static  File getFileFromBytes( byte [] b)
{
     BufferedOutputStream stream =  null ;
     File file =  null ;
     try
     {
         // 判断SDcard状态
         if  (!Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()))
         {
             // 错误提示
             return  null ;
         }
                                                                                                                                                                                                                       
         // 检查SDcard空间
         File SDCardRoot = Environment.getExternalStorageDirectory();
         if  (SDCardRoot.getFreeSpace() <  10000 )
         {
             // 弹出对话框提示用户空间不够
             Log.e( "Utils" ,  "存储空间不够" );
             return  null ;
         }
                                                                                                                                                                                                                       
         // 在SDcard创建文件夹及文件
         File bitmapFile =  new  File(SDCardRoot.getPath() + FILE_PATH);
         bitmapFile.getParentFile().mkdirs(); // 创建文件夹
                                                                                                                                                                                                                       
         FileOutputStream fstream =  new  FileOutputStream(bitmapFile);
         stream =  new  BufferedOutputStream(fstream);
         stream.write(b);
     }
     catch  (Exception e)
     {
         e.printStackTrace();
     }
     finally
     {
         if  (stream !=  null )
         {
             try
             {
                 stream.close();
             }
             catch  (IOException e1)
             {
                 e1.printStackTrace();
             }
         }
     }
     return  file;
}




14.图片压缩

1
2
3
4
5
6
7
8
9
10
11
12
13
//图片缩放
public  static  Bitmap scaleDownBitmap(Bitmap photo,  int  newHeight, Context context)
{
                                                                                                                                                                                                        
     final  float  densityMultiplier = context.getResources().getDisplayMetrics().density;
                                                                                                                                                                                                        
     int  h = ( int ) (newHeight * densityMultiplier);
     int  w = ( int ) (h * photo.getWidth() / (( double ) photo.getHeight()));
                                                                                                                                                                                                        
     photo = Bitmap.createScaledBitmap(photo, w, h,  true );
                                                                                                                                                                                                        
     return  photo;
}


15.将byte[]转换成InputStream

1
2
3
4
5
6
// 将byte[]转换成InputStream
public  InputStream Byte2InputStream( byte [] b)
{
     ByteArrayInputStream bais =  new  ByteArrayInputStream(b);
     return  bais;
}



16.将InputStream转换成byte[]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 将InputStream转换成byte[]
public  byte [] InputStream2Bytes(InputStream is)
{
     String str =  "" ;
     byte [] readByte =  new  byte [ 1024 ];
     int  readCount = - 1 ;
     try
     {
         while  ((readCount = is.read(readByte,  0 ,  1024 )) != - 1 )
         {
             str +=  new  String(readByte).trim();
         }
         return  str.getBytes();
     }
     catch  (Exception e)
     {
         e.printStackTrace();
     }
     return  null ;
}



17.将Bitmap转换成InputStream

1
2
3
4
5
6
7
8
// 将Bitmap转换成InputStream
public  InputStream Bitmap2InputStream(Bitmap bm)
{
     ByteArrayOutputStream baos =  new  ByteArrayOutputStream();
     bm.compress(Bitmap.CompressFormat.JPEG,  100 , baos);
     InputStream is =  new  ByteArrayInputStream(baos.toByteArray());
     return  is;
}



18.将Bitmap转换成InputStream

1
2
3
4
5
6
7
8
// 将Bitmap转换成InputStream
public  InputStream Bitmap2InputStream(Bitmap bm,  int  quality)
{
     ByteArrayOutputStream baos =  new  ByteArrayOutputStream();
     bm.compress(Bitmap.CompressFormat.PNG, quality, baos);
     InputStream is =  new  ByteArrayInputStream(baos.toByteArray());
     return  is;
}



19.将InputStream转换成Bitmap

1
2
3
4
5
// 将InputStream转换成Bitmap
public  Bitmap InputStream2Bitmap(InputStream is)
{
     return  BitmapFactory.decodeStream(is);
}


20.Drawable转换成InputStream

1
2
3
4
5
6
// Drawable转换成InputStream
public  InputStream Drawable2InputStream(Drawable d)
{
     Bitmap bitmap =  this .drawable2Bitmap(d);
     return  this .Bitmap2InputStream(bitmap);
}




21.InputStream转换成Drawable

1
2
3
4
5
6
// InputStream转换成Drawable
public  Drawable InputStream2Drawable(InputStream is)
{
     Bitmap bitmap =  this .InputStream2Bitmap(is);
     return  this .bitmap2Drawable(bitmap);
}


22.Drawable转换成byte[]

1
2
3
4
5
6
// Drawable转换成byte[]
public  byte [] Drawable2Bytes(Drawable d)
{
     Bitmap bitmap =  this .drawable2Bitmap(d);
     return  this .Bitmap2Bytes(bitmap);
}




23.byte[]转换成Drawable

1
2
3
4
5
6
// byte[]转换成Drawable
public  Drawable Bytes2Drawable( byte [] b)
{
     Bitmap bitmap =  this .Bytes2Bitmap(b);
     return  this .bitmap2Drawable(bitmap);
}



24.Drawable转换成Bitmap

1
2
3
4
5
6
7
8
9
10
// Drawable转换成Bitmap
public  Bitmap drawable2Bitmap(Drawable drawable)
{
     Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(),
             drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565);
     Canvas canvas =  new  Canvas(bitmap);
     drawable.setBounds( 0 ,  0 , drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
     drawable.draw(canvas);
     return  bitmap;
}



25.Bitmap转换成Drawable

1
2
3
4
5
6
7
// Bitmap转换成Drawable
public  Drawable bitmap2Drawable(Bitmap bitmap)
{
     BitmapDrawable bd =  new  BitmapDrawable(bitmap);
     Drawable d = (Drawable) bd;
     return  d;
}






本文转自 glblong 51CTO博客，原文链接：http://blog.51cto.com/glblong/1304090，如需转载请自行联系原作者

上一篇 下一篇
优秀的个人博客,低调大师

微信关注我们

原文链接：https://yq.aliyun.com/articles/425359

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Android Fragment间对象传递

　由于Activity相对较为笨重，因而在日常的开发中很多时候会用到Fragment。然而Activity之间是通过Intent进行数据的传递，那Fragment是通过什么来进行传递的呢？Fragment之间又是通过什么方式来进行对象的传递呢？ Android控件之间传递（Activity和Activity间传递对象、Fragment和Fragment间传递对象）对象有两种实现方式。一种是实现Java提供的Serializable接口，另一种是实现android提供的Parcelable接口。两者之间各有优势；实现Serializable接口的话最简单，直接添加接口的实现即可，但是效率较低；实现Parcelable的话效率较高，但需要自己实现Parcelable的方法。下面看下两种方法的具体实现： 原有Article类 package com.example.news.andoridnewsapp; public class Article { private String title; private String linkmd5; private String link; priv...
2017-11-29
508
上一篇

android 中文 api （71） —— BluetoothServerSocket[蓝牙]

正文 一、结构 public final classBluetoothServerSocket extendsObjectimplementsCloseable java.lang.Object android.bluetooth.BluetoothServerSocket 二、概述 一个蓝牙监听端口。 蓝牙端口监听接口和TCP端口类似：Socket和ServerSocket类。在服务器端，使用BluetoothServerSocket类来创建一个监听服务端口。当一个连接被BluetoothServerSocket所接受，它会返回一个新的BluetoothSocket来管理该连接。在客户端，使用一个单独的BluetoothSocket类去初始化一个外接连接和管理该连接。 最通常使用的蓝牙端口是RFCOMM，它是被Android API支持的类型。RFCOMM是一个面向连接，通过蓝牙模块进行的数据流传输方式，它也被称为串行端口规范（Serial Port Profile，SPP）。 为了创建一个对准备好的新来的连接去进行监听BluetoothServerSocket类，使用Bluet...
2017-11-30
618
下一篇

相关文章

发表评论

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2025-12-12 大小: 211.28KB 下载: 54次
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2025-12-28 大小: 1MB 下载: 4次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
手机查看

扫码在手机上查看文章

扫描二维码，手机阅读更方便

热门标签
SpringCloud SpringBoot4 Jdk25 Docker Kubernetes OpenAi Rocky Nacos3 DeepSeek Service Mesh HarmonyOS6 Redis Gemini3

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册