How can I get list of all drives but also get the corresponding drive type (removable,local disk, or cd-rom,dvd-rom... etc)?

How can I get list all drives but 开发者_JAVA百科also get the corresponding drive type (removable, local disk, or cd-rom, dvd-rom, etc)?

With this code you can get all drives and its type description

File[] paths;
FileSystemView fsv = FileSystemView.getFileSystemView();

// returns pathnames for files and directory
paths = File.listRoots();

// for each pathname in pathname array
for(File path:paths)
{
    // prints file and directory paths
    System.out.println("Drive Name: "+path);
    System.out.println("Description: "+fsv.getSystemTypeDescription(path));
}

Assuming it's windows, use File.listRoots() to get all roots. Then use FileSystemView to check whether it's floppy disk or a drive. Other than that I have no idea.

This code snippet works on Windows. It correctly reports USB pen drives as removable, but on my laptop a USB hard drive is marked as non removable. Anyway this is the best I found without using native code.

for (Path root : FileSystems.getDefault().getRootDirectories()) {
  FileStore fileStore = Files.getFileStore(root);
  System.out.format("%s\t%s\n", root, fileStore.getAttribute("volume:isRemovable"));
}

Source: this file that apparently comes from the JDK

There's no definition for what you're asking.

I have a thumb drive which, when I plug it in, shows up as a CD-ROM. After I run a program on the CD-ROM it attaches a second partition which appears to be a hard drive.

I have removable CD-ROM drives. I also have "internal" eSATA hard drives on the outside of my computer.

You'd have to work pretty hard to get a binding definition for the "type" of the drive. Why don't you tell us what you're trying to do, instead of asking about the particular way you want to do it?

If you use JACOB, you can list all drives along with appropriate types:

import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.EnumVariant;
import com.jacob.com.JacobObject;
import com.jacob.com.Variant;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class DrivesExample
{
    public interface HasNativeValue
    {
        int getNativeValue();
    }

    public enum DriveTypeEnum implements HasNativeValue
    {
        Unknown(0),
        NoRootDirectory(1),
        RemovableDisk(2),
        LocalDisk(3),
        NetworkDrive(4),
        CompactDisc(5),
        RAMDisk(6);

        public final int nativeValue;

        DriveTypeEnum(int nativeValue)
        {
            this.nativeValue = nativeValue;
        }

        public int getNativeValue()
        {
            return nativeValue;
        }
    }

    private static <T extends Enum<T> & HasNativeValue> T fromNative(Class<T> clazz, int value)
    {
        for (T c : clazz.getEnumConstants())
        {
            if (c.getNativeValue() == value)
            {
                return c;
            }
        }
        return null;
    }

    /**
     * The drive information.
     */
    public static final class Drive
    {
        /**
         * File system on the logical disk. Example: NTFS. null if not known.
         */
        public final String fileSystem;
        /**
         * Value that corresponds to the type of disk drive this logical disk represents.
         */
        public final DriveTypeEnum driveType;
        /**
         * The Java file, e.g. "C:\". Never null.
         */
        public final File file;

        public Drive(String fileSystem, DriveTypeEnum driveType, File file)
        {
            this.fileSystem = fileSystem;
            this.driveType = driveType;
            this.file = file;
        }

        @Override
        public String toString()
        {
            return "Drive{" + file + ": " + driveType + ", fileSystem=" + fileSystem + "}";
        }
    }

    /**
     * Lists all available Windows drives without actually touching them. This call should not block on cd-roms, floppies, network drives etc.
     *
     * @return a list of drives, never null, may be empty.
     */
    public static List<Drive> getDrives()
    {
        List<Drive> result = new ArrayList<>();
        ActiveXComponent axWMI = new ActiveXComponent("winmgmts://");

        try
        {
            Variant devices = axWMI.invoke("ExecQuery", new Variant("Select DeviceID,DriveType,FileSystem from Win32_LogicalDisk"));
            EnumVariant deviceList = new EnumVariant(devices.toDispatch());
            while (deviceList.hasMoreElements())
            {
                Dispatch item = deviceList.nextElement().toDispatch();
                String drive = Dispatch.call(item, "DeviceID").toString().toUpperCase();
                File file = new File(drive + "/");
                DriveTypeEnum driveType = fromNative(DriveTypeEnum.class, Dispatch.call(item, "DriveType").getInt());
                String fileSystem = Dispatch.call(item, "FileSystem").toString();
                result.add(new Drive(fileSystem, driveType, file));
            }

            return result;
        } finally
        {
            closeQuietly(axWMI);
        }
    }

    private static void closeQuietly(JacobObject jacobObject)
    {
        try
        {
            jacobObject.safeRelease();
        } catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }

    public static void main(String[] arguments)
    {
        List<Drive> drives = getDrives();

        for (Drive drive : drives)
        {
            System.out.println(drive.toString());
        }
    }
}

Example output:

Drive{C:\: LocalDisk, fileSystem=NTFS}
Drive{D:\: LocalDisk, fileSystem=NTFS}
Drive{E:\: RemovableDisk, fileSystem=NTFS}
Drive{F:\: RemovableDisk, fileSystem=FAT32}
Drive{G:\: RemovableDisk, fileSystem=null}
Drive{Y:\: NetworkDrive, fileSystem=NTFS}

To use JACOB, add the JAR and DLL's from the download as libraries in your project. This solution is Windows only of course.

File[] roots = File.listRoots();
for(int i=0;i<roots.length;i++)
    System.out.println("Root["+i+"]:" + roots[i]);

The correct way is how Luciano answered with isRemovable property, but I recently had on win 10 that if I started from USB, then USBs were no longer found in that method.

So, I used, for Windows only, the following wmic calls:

ArrayList<File> rootDirs = new ArrayList<File>();
if( isWin )
{


  if( i_dolog )
    LOG.info( "Windows found as OS." );
  ArrayList<String> partids = new ArrayList<String>();

  String results0 = execute( "wmic diskdrive where interfacetype='USB' assoc /assocclass:Win32_DiskDriveToDiskPartition" );
  String lines[] = results0.split( "\r\r\n" );
  for( String line : lines )
  {
    String test = "Win32_DiskPartition.DeviceID=";
    int index = line.indexOf( test );
    if( index >= 0 )
    {
      String partid = line.substring( index + test.length() + 1 );
      partid = partid.substring( 0, partid.indexOf( '"' ) );
      partids.add( partid );
    }
  }
  for( String partition : partids )
  {
    String results2 = execute( "wmic partition where (DeviceID='" + partition + "') assoc /assocclass:Win32_LogicalDiskToPartition" );
    String lines2[] = results2.split( "\r\r\n" );
    for( String line : lines2 )
    {
      String test = "Win32_LogicalDisk.DeviceID=";
      int index = line.indexOf( test );
      if( index >= 0 )
      {
        String partid = line.substring( index + test.length() + 1 );
        partid = partid.substring( 0, partid.indexOf( '"' ) );
        rootDirs.add( new File( partid + "\\" ) );
      }
    }
  }
}